Function instantiateMappedGenericTupleType

test/fixtures/snapshot/typescript.js:63541–63556

(tupleType, mappedType, typeVariable, mapper)

            return modifiers & 1 /* MappedTypeModifiers.IncludeReadonly */ ? true : modifiers & 2 /* MappedTypeModifiers.ExcludeReadonly */ ? false : state;
        }
        function instantiateMappedGenericTupleType(tupleType, mappedType, typeVariable, mapper) {
            // When a tuple type is generic (i.e. when it contains variadic elements), we want to eagerly map the
            // non-generic elements and defer mapping the generic elements. In order to facilitate this, we transform
            // M<[A, B?, ...T, ...C[]] into [...M<[A]>, ...M<[B?]>, ...M<T>, ...M<C[]>] and then rely on tuple type
            // normalization to resolve the non-generic parts of the resulting tuple.
            var elementFlags = tupleType.target.elementFlags;
            var elementTypes = ts.map(getTypeArguments(tupleType), function (t, i) {
                var singleton = elementFlags[i] & 8 /* ElementFlags.Variadic */ ? t :
                    elementFlags[i] & 4 /* ElementFlags.Rest */ ? createArrayType(t) :
                        createTupleType([t], [elementFlags[i]]);
                // The singleton is never a generic tuple type, so it is safe to recurse here.
                return instantiateMappedType(mappedType, prependTypeMapping(typeVariable, singleton, mapper));
            });
            var newReadonly = getModifiedReadonlyState(tupleType.target.readonly, getMappedTypeModifiers(mappedType));
            return createTupleType(elementTypes, ts.map(elementTypes, function (_) { return 8 /* ElementFlags.Variadic */; }), newReadonly);
        }
        function instantiateMappedArrayType(arrayType, mappedType, mapper) {
            var elementType = instantiateMappedTypeTemplate(mappedType, numberType, /*isOptional*/ true, mapper);
            return isErrorType(elementType) ? errorType :