function extractEntry(stream: Readable, fileName: string, mode: number, targetPath: string, options: IOptions, token: CancellationToken): Promise<void> {
	const dirName = path.dirname(fileName);
	const targetDirName = path.join(targetPath, dirName);
	if (targetDirName.indexOf(targetPath) !== 0) {
		return Promise.reject(new Error(nls.localize('invalid file', "Error extracting {0}. Invalid file.", fileName)));
	}
	const targetFileName = path.join(targetPath, fileName);

	let istream: WriteStream;

	once(token.onCancellationRequested)(() => {
		if (istream) {
			istream.close();
		}
	});

	return Promise.resolve(mkdirp(targetDirName, void 0, token)).then(() => new Promise((c, e) => {
		if (token.isCancellationRequested) {
			return;
		}

		try {
			istream = createWriteStream(targetFileName, { mode });
			istream.once('close', () => c(null));
			istream.once('error', e);
			stream.once('error', e);
			stream.pipe(istream);
		} catch (error) {
			e(error);
		}
	}));
}

function extractZip(zipfile: ZipFile, targetPath: string, options: IOptions, logService: ILogService, token: CancellationToken): Promise<void> {
	let last = createCancelablePromise(() => Promise.resolve(null));
	let extractedEntriesCount = 0;

	once(token.onCancellationRequested)(() => {
		logService.debug(targetPath, 'Cancelled.');
		last.cancel();
		zipfile.close();
	});

	return new Promise((c, e) => {
		const throttler = new SimpleThrottler();

		const readNextEntry = (token: CancellationToken) => {
			if (token.isCancellationRequested) {
				return;
			}

			extractedEntriesCount++;
			zipfile.readEntry();
		};

		zipfile.once('error', e);
		zipfile.once('close', () => last.then(() => {
			if (token.isCancellationRequested || zipfile.entryCount === extractedEntriesCount) {
				c(null);
			} else {
				e(new ExtractError('Incomplete', new Error(nls.localize('incompleteExtract', "Incomplete. Found {0} of {1} entries", extractedEntriesCount, zipfile.entryCount))));
			}
		}, e));
		zipfile.readEntry();
		zipfile.on('entry', (entry: Entry) => {

			if (token.isCancellationRequested) {
				return;
			}

			if (!options.sourcePathRegex.test(entry.fileName)) {
				readNextEntry(token);
				return;
			}

			const fileName = entry.fileName.replace(options.sourcePathRegex, '');

			// directory file names end with '/'
			if (/\/$/.test(fileName)) {
				const targetFileName = path.join(targetPath, fileName);
				last = createCancelablePromise(token => mkdirp(targetFileName, void 0, token).then(() => readNextEntry(token)).then(null, e));
				return;
			}

			const stream = ninvoke(zipfile, zipfile.openReadStream, entry);
			const mode = modeFromEntry(entry);

			last = createCancelablePromise(token => throttler.queue(() => stream.then(stream => extractEntry(stream, fileName, mode, targetPath, options, token).then(() => readNextEntry(token)))).then(null, e));
		});
	});
}

	private triggerAriaAlert(notifiation: INotificationViewItem): void {

		// Trigger the alert again whenever the label changes
		const listener = notifiation.onDidLabelChange(e => {
			if (e.kind === NotificationViewItemLabelKind.MESSAGE) {
				this.doTriggerAriaAlert(notifiation);
			}
		});

		once(notifiation.onDidClose)(() => listener.dispose());

		this.doTriggerAriaAlert(notifiation);
	}

function ensureWriteFileQueue(queueKey: string): Queue<void> {
	let writeFileQueue = writeFilePathQueue[queueKey];
	if (!writeFileQueue) {
		writeFileQueue = new Queue<void>();
		writeFilePathQueue[queueKey] = writeFileQueue;

		const onFinish = once(writeFileQueue.onFinished);
		onFinish(() => {
			delete writeFilePathQueue[queueKey];
			writeFileQueue.dispose();
		});
	}

	return writeFileQueue;
}

		const promise = new TPromise<number>(c => {

			// Complete promise with index of action that was picked
			const callback = (index: number, closeNotification: boolean) => () => {
				c(index);

				if (closeNotification) {
					handle.dispose();
				}

				return TPromise.as(void 0);
			};

			// Convert choices into primary/secondary actions
			const actions: INotificationActions = {
				primary: [],
				secondary: []
			};

			choices.forEach((choice, index) => {
				let isPrimary = true;
				let label: string;
				let closeNotification = false;

				if (typeof choice === 'string') {
					label = choice;
				} else {
					isPrimary = false;
					label = choice.label;
					closeNotification = !choice.keepOpen;
				}

				const action = new Action(`workbench.dialog.choice.${index}`, label, null, true, callback(index, closeNotification));
				if (isPrimary) {
					actions.primary.push(action);
				} else {
					actions.secondary.push(action);
				}
			});

			// Show notification with actions
			handle = this.notify({ severity, message, actions });

			// Cancel promise when notification gets disposed
			once(handle.onDidDispose)(() => promise.cancel());

		}, () => handle.dispose());

	public prompt(severity: Severity, message: string, choices: IPromptChoice[], onCancel?: () => void): INotificationHandle {
		let handle: INotificationHandle;
		let choiceClicked = false;

		// Convert choices into primary/secondary actions
		const actions: INotificationActions = { primary: [], secondary: [] };
		choices.forEach((choice, index) => {
			const action = new Action(`workbench.dialog.choice.${index}`, choice.label, null, true, () => {
				choiceClicked = true;

				// Pass to runner
				choice.run();

				// Close notification unless we are told to keep open
				if (!choice.keepOpen) {
					handle.close();
				}

				return TPromise.as(void 0);
			});

			if (!choice.isSecondary) {
				actions.primary.push(action);
			} else {
				actions.secondary.push(action);
			}
		});

		// Show notification with actions
		handle = this.notify({ severity, message, actions });

		once(handle.onDidClose)(() => {

			// Cleanup when notification gets disposed
			dispose(...actions.primary, ...actions.secondary);

			// Indicate cancellation to the outside if no action was executed
			if (!choiceClicked && typeof onCancel === 'function') {
				onCancel();
			}
		});

		return handle;
	}