Merge commit 'be3e8236086165e5e45a5a10783823874b3f3ebd' as 'lib/vscode'

lib/vscode/extensions/css-language-features/server/src/browser/cssServerMain.ts

@@ -0,0 +1,16 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { createConnection, BrowserMessageReader, BrowserMessageWriter } from 'vscode-languageserver/browser';
+import { startServer } from '../cssServer';
+
+declare let self: any;
+
+const messageReader = new BrowserMessageReader(self);
+const messageWriter = new BrowserMessageWriter(self);
+
+const connection = createConnection(messageReader, messageWriter);
+
+startServer(connection, {});

lib/vscode/extensions/css-language-features/server/src/cssServer.ts

@@ -0,0 +1,373 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import {
+	Connection, TextDocuments, InitializeParams, InitializeResult, ServerCapabilities, ConfigurationRequest, WorkspaceFolder, TextDocumentSyncKind, NotificationType
+} from 'vscode-languageserver';
+import { URI } from 'vscode-uri';
+import { getCSSLanguageService, getSCSSLanguageService, getLESSLanguageService, LanguageSettings, LanguageService, Stylesheet, TextDocument, Position } from 'vscode-css-languageservice';
+import { getLanguageModelCache } from './languageModelCache';
+import { formatError, runSafeAsync } from './utils/runner';
+import { getDocumentContext } from './utils/documentContext';
+import { fetchDataProviders } from './customData';
+import { RequestService, getRequestService } from './requests';
+
+namespace CustomDataChangedNotification {
+	export const type: NotificationType<string[]> = new NotificationType('css/customDataChanged');
+}
+
+export interface Settings {
+	css: LanguageSettings;
+	less: LanguageSettings;
+	scss: LanguageSettings;
+}
+
+export interface RuntimeEnvironment {
+	file?: RequestService;
+	http?: RequestService
+}
+
+export function startServer(connection: Connection, runtime: RuntimeEnvironment) {
+
+	// Create a text document manager.
+	const documents = new TextDocuments(TextDocument);
+	// Make the text document manager listen on the connection
+	// for open, change and close text document events
+	documents.listen(connection);
+
+	const stylesheets = getLanguageModelCache<Stylesheet>(10, 60, document => getLanguageService(document).parseStylesheet(document));
+	documents.onDidClose(e => {
+		stylesheets.onDocumentRemoved(e.document);
+	});
+	connection.onShutdown(() => {
+		stylesheets.dispose();
+	});
+
+	let scopedSettingsSupport = false;
+	let foldingRangeLimit = Number.MAX_VALUE;
+	let workspaceFolders: WorkspaceFolder[];
+
+	let dataProvidersReady: Promise<any> = Promise.resolve();
+
+	const languageServices: { [id: string]: LanguageService } = {};
+
+	const notReady = () => Promise.reject('Not Ready');
+	let requestService: RequestService = { getContent: notReady, stat: notReady, readDirectory: notReady };
+
+	// After the server has started the client sends an initialize request. The server receives
+	// in the passed params the rootPath of the workspace plus the client capabilities.
+	connection.onInitialize((params: InitializeParams): InitializeResult => {
+		workspaceFolders = (<any>params).workspaceFolders;
+		if (!Array.isArray(workspaceFolders)) {
+			workspaceFolders = [];
+			if (params.rootPath) {
+				workspaceFolders.push({ name: '', uri: URI.file(params.rootPath).toString() });
+			}
+		}
+
+		requestService = getRequestService(params.initializationOptions?.handledSchemas || ['file'], connection, runtime);
+
+		function getClientCapability<T>(name: string, def: T) {
+			const keys = name.split('.');
+			let c: any = params.capabilities;
+			for (let i = 0; c && i < keys.length; i++) {
+				if (!c.hasOwnProperty(keys[i])) {
+					return def;
+				}
+				c = c[keys[i]];
+			}
+			return c;
+		}
+		const snippetSupport = !!getClientCapability('textDocument.completion.completionItem.snippetSupport', false);
+		scopedSettingsSupport = !!getClientCapability('workspace.configuration', false);
+		foldingRangeLimit = getClientCapability('textDocument.foldingRange.rangeLimit', Number.MAX_VALUE);
+
+		languageServices.css = getCSSLanguageService({ fileSystemProvider: requestService, clientCapabilities: params.capabilities });
+		languageServices.scss = getSCSSLanguageService({ fileSystemProvider: requestService, clientCapabilities: params.capabilities });
+		languageServices.less = getLESSLanguageService({ fileSystemProvider: requestService, clientCapabilities: params.capabilities });
+
+		const capabilities: ServerCapabilities = {
+			textDocumentSync: TextDocumentSyncKind.Incremental,
+			completionProvider: snippetSupport ? { resolveProvider: false, triggerCharacters: ['/', '-'] } : undefined,
+			hoverProvider: true,
+			documentSymbolProvider: true,
+			referencesProvider: true,
+			definitionProvider: true,
+			documentHighlightProvider: true,
+			documentLinkProvider: {
+				resolveProvider: false
+			},
+			codeActionProvider: true,
+			renameProvider: true,
+			colorProvider: {},
+			foldingRangeProvider: true,
+			selectionRangeProvider: true
+		};
+		return { capabilities };
+	});
+
+	function getLanguageService(document: TextDocument) {
+		let service = languageServices[document.languageId];
+		if (!service) {
+			connection.console.log('Document type is ' + document.languageId + ', using css instead.');
+			service = languageServices['css'];
+		}
+		return service;
+	}
+
+	let documentSettings: { [key: string]: Thenable<LanguageSettings | undefined> } = {};
+	// remove document settings on close
+	documents.onDidClose(e => {
+		delete documentSettings[e.document.uri];
+	});
+	function getDocumentSettings(textDocument: TextDocument): Thenable<LanguageSettings | undefined> {
+		if (scopedSettingsSupport) {
+			let promise = documentSettings[textDocument.uri];
+			if (!promise) {
+				const configRequestParam = { items: [{ scopeUri: textDocument.uri, section: textDocument.languageId }] };
+				promise = connection.sendRequest(ConfigurationRequest.type, configRequestParam).then(s => s[0]);
+				documentSettings[textDocument.uri] = promise;
+			}
+			return promise;
+		}
+		return Promise.resolve(undefined);
+	}
+
+	// The settings have changed. Is send on server activation as well.
+	connection.onDidChangeConfiguration(change => {
+		updateConfiguration(<Settings>change.settings);
+	});
+
+	function updateConfiguration(settings: Settings) {
+		for (const languageId in languageServices) {
+			languageServices[languageId].configure((settings as any)[languageId]);
+		}
+		// reset all document settings
+		documentSettings = {};
+		// Revalidate any open text documents
+		documents.all().forEach(triggerValidation);
+	}
+
+	const pendingValidationRequests: { [uri: string]: NodeJS.Timer } = {};
+	const validationDelayMs = 500;
+
+	// The content of a text document has changed. This event is emitted
+	// when the text document first opened or when its content has changed.
+	documents.onDidChangeContent(change => {
+		triggerValidation(change.document);
+	});
+
+	// a document has closed: clear all diagnostics
+	documents.onDidClose(event => {
+		cleanPendingValidation(event.document);
+		connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
+	});
+
+	function cleanPendingValidation(textDocument: TextDocument): void {
+		const request = pendingValidationRequests[textDocument.uri];
+		if (request) {
+			clearTimeout(request);
+			delete pendingValidationRequests[textDocument.uri];
+		}
+	}
+
+	function triggerValidation(textDocument: TextDocument): void {
+		cleanPendingValidation(textDocument);
+		pendingValidationRequests[textDocument.uri] = setTimeout(() => {
+			delete pendingValidationRequests[textDocument.uri];
+			validateTextDocument(textDocument);
+		}, validationDelayMs);
+	}
+
+	function validateTextDocument(textDocument: TextDocument): void {
+		const settingsPromise = getDocumentSettings(textDocument);
+		Promise.all([settingsPromise, dataProvidersReady]).then(async ([settings]) => {
+			const stylesheet = stylesheets.get(textDocument);
+			const diagnostics = getLanguageService(textDocument).doValidation(textDocument, stylesheet, settings);
+			// Send the computed diagnostics to VSCode.
+			connection.sendDiagnostics({ uri: textDocument.uri, diagnostics });
+		}, e => {
+			connection.console.error(formatError(`Error while validating ${textDocument.uri}`, e));
+		});
+	}
+
+
+	function updateDataProviders(dataPaths: string[]) {
+		dataProvidersReady = fetchDataProviders(dataPaths, requestService).then(customDataProviders => {
+			for (const lang in languageServices) {
+				languageServices[lang].setDataProviders(true, customDataProviders);
+			}
+		});
+	}
+
+	connection.onCompletion((textDocumentPosition, token) => {
+		return runSafeAsync(async () => {
+			const document = documents.get(textDocumentPosition.textDocument.uri);
+			if (document) {
+				await dataProvidersReady;
+				const styleSheet = stylesheets.get(document);
+				const documentContext = getDocumentContext(document.uri, workspaceFolders);
+				return getLanguageService(document).doComplete2(document, textDocumentPosition.position, styleSheet, documentContext);
+			}
+			return null;
+		}, null, `Error while computing completions for ${textDocumentPosition.textDocument.uri}`, token);
+	});
+
+	connection.onHover((textDocumentPosition, token) => {
+		return runSafeAsync(async () => {
+			const document = documents.get(textDocumentPosition.textDocument.uri);
+			if (document) {
+				await dataProvidersReady;
+				const styleSheet = stylesheets.get(document);
+				return getLanguageService(document).doHover(document, textDocumentPosition.position, styleSheet);
+			}
+			return null;
+		}, null, `Error while computing hover for ${textDocumentPosition.textDocument.uri}`, token);
+	});
+
+	connection.onDocumentSymbol((documentSymbolParams, token) => {
+		return runSafeAsync(async () => {
+			const document = documents.get(documentSymbolParams.textDocument.uri);
+			if (document) {
+				await dataProvidersReady;
+				const stylesheet = stylesheets.get(document);
+				return getLanguageService(document).findDocumentSymbols(document, stylesheet);
+			}
+			return [];
+		}, [], `Error while computing document symbols for ${documentSymbolParams.textDocument.uri}`, token);
+	});
+
+	connection.onDefinition((documentDefinitionParams, token) => {
+		return runSafeAsync(async () => {
+			const document = documents.get(documentDefinitionParams.textDocument.uri);
+			if (document) {
+				await dataProvidersReady;
+				const stylesheet = stylesheets.get(document);
+				return getLanguageService(document).findDefinition(document, documentDefinitionParams.position, stylesheet);
+			}
+			return null;
+		}, null, `Error while computing definitions for ${documentDefinitionParams.textDocument.uri}`, token);
+	});
+
+	connection.onDocumentHighlight((documentHighlightParams, token) => {
+		return runSafeAsync(async () => {
+			const document = documents.get(documentHighlightParams.textDocument.uri);
+			if (document) {
+				await dataProvidersReady;
+				const stylesheet = stylesheets.get(document);
+				return getLanguageService(document).findDocumentHighlights(document, documentHighlightParams.position, stylesheet);
+			}
+			return [];
+		}, [], `Error while computing document highlights for ${documentHighlightParams.textDocument.uri}`, token);
+	});
+
+
+	connection.onDocumentLinks(async (documentLinkParams, token) => {
+		return runSafeAsync(async () => {
+			const document = documents.get(documentLinkParams.textDocument.uri);
+			if (document) {
+				await dataProvidersReady;
+				const documentContext = getDocumentContext(document.uri, workspaceFolders);
+				const stylesheet = stylesheets.get(document);
+				return getLanguageService(document).findDocumentLinks2(document, stylesheet, documentContext);
+			}
+			return [];
+		}, [], `Error while computing document links for ${documentLinkParams.textDocument.uri}`, token);
+	});
+
+
+	connection.onReferences((referenceParams, token) => {
+		return runSafeAsync(async () => {
+			const document = documents.get(referenceParams.textDocument.uri);
+			if (document) {
+				await dataProvidersReady;
+				const stylesheet = stylesheets.get(document);
+				return getLanguageService(document).findReferences(document, referenceParams.position, stylesheet);
+			}
+			return [];
+		}, [], `Error while computing references for ${referenceParams.textDocument.uri}`, token);
+	});
+
+	connection.onCodeAction((codeActionParams, token) => {
+		return runSafeAsync(async () => {
+			const document = documents.get(codeActionParams.textDocument.uri);
+			if (document) {
+				await dataProvidersReady;
+				const stylesheet = stylesheets.get(document);
+				return getLanguageService(document).doCodeActions(document, codeActionParams.range, codeActionParams.context, stylesheet);
+			}
+			return [];
+		}, [], `Error while computing code actions for ${codeActionParams.textDocument.uri}`, token);
+	});
+
+	connection.onDocumentColor((params, token) => {
+		return runSafeAsync(async () => {
+			const document = documents.get(params.textDocument.uri);
+			if (document) {
+				await dataProvidersReady;
+				const stylesheet = stylesheets.get(document);
+				return getLanguageService(document).findDocumentColors(document, stylesheet);
+			}
+			return [];
+		}, [], `Error while computing document colors for ${params.textDocument.uri}`, token);
+	});
+
+	connection.onColorPresentation((params, token) => {
+		return runSafeAsync(async () => {
+			const document = documents.get(params.textDocument.uri);
+			if (document) {
+				await dataProvidersReady;
+				const stylesheet = stylesheets.get(document);
+				return getLanguageService(document).getColorPresentations(document, stylesheet, params.color, params.range);
+			}
+			return [];
+		}, [], `Error while computing color presentations for ${params.textDocument.uri}`, token);
+	});
+
+	connection.onRenameRequest((renameParameters, token) => {
+		return runSafeAsync(async () => {
+			const document = documents.get(renameParameters.textDocument.uri);
+			if (document) {
+				await dataProvidersReady;
+				const stylesheet = stylesheets.get(document);
+				return getLanguageService(document).doRename(document, renameParameters.position, renameParameters.newName, stylesheet);
+			}
+			return null;
+		}, null, `Error while computing renames for ${renameParameters.textDocument.uri}`, token);
+	});
+
+	connection.onFoldingRanges((params, token) => {
+		return runSafeAsync(async () => {
+			const document = documents.get(params.textDocument.uri);
+			if (document) {
+				await dataProvidersReady;
+				return getLanguageService(document).getFoldingRanges(document, { rangeLimit: foldingRangeLimit });
+			}
+			return null;
+		}, null, `Error while computing folding ranges for ${params.textDocument.uri}`, token);
+	});
+
+	connection.onSelectionRanges((params, token) => {
+		return runSafeAsync(async () => {
+			const document = documents.get(params.textDocument.uri);
+			const positions: Position[] = params.positions;
+
+			if (document) {
+				await dataProvidersReady;
+				const stylesheet = stylesheets.get(document);
+				return getLanguageService(document).getSelectionRanges(document, positions, stylesheet);
+			}
+			return [];
+		}, [], `Error while computing selection ranges for ${params.textDocument.uri}`, token);
+	});
+
+	connection.onNotification(CustomDataChangedNotification.type, updateDataProviders);
+
+	// Listen on the connection
+	connection.listen();
+
+}
+
+

lib/vscode/extensions/css-language-features/server/src/customData.ts

@@ -0,0 +1,38 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ICSSDataProvider, newCSSDataProvider } from 'vscode-css-languageservice';
+import { RequestService } from './requests';
+
+export function fetchDataProviders(dataPaths: string[], requestService: RequestService): Promise<ICSSDataProvider[]> {
+	const providers = dataPaths.map(async p => {
+		try {
+			const content = await requestService.getContent(p);
+			return parseCSSData(content);
+		} catch (e) {
+			return newCSSDataProvider({ version: 1 });
+		}
+	});
+
+	return Promise.all(providers);
+}
+
+function parseCSSData(source: string): ICSSDataProvider {
+	let rawData: any;
+
+	try {
+		rawData = JSON.parse(source);
+	} catch (err) {
+		return newCSSDataProvider({ version: 1 });
+	}
+
+	return newCSSDataProvider({
+		version: rawData.version || 1,
+		properties: rawData.properties || [],
+		atDirectives: rawData.atDirectives || [],
+		pseudoClasses: rawData.pseudoClasses || [],
+		pseudoElements: rawData.pseudoElements || []
+	});
+}

lib/vscode/extensions/css-language-features/server/src/languageModelCache.ts

@@ -0,0 +1,82 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { TextDocument } from 'vscode-languageserver';
+
+export interface LanguageModelCache<T> {
+	get(document: TextDocument): T;
+	onDocumentRemoved(document: TextDocument): void;
+	dispose(): void;
+}
+
+export function getLanguageModelCache<T>(maxEntries: number, cleanupIntervalTimeInSec: number, parse: (document: TextDocument) => T): LanguageModelCache<T> {
+	let languageModels: { [uri: string]: { version: number, languageId: string, cTime: number, languageModel: T } } = {};
+	let nModels = 0;
+
+	let cleanupInterval: NodeJS.Timer | undefined = undefined;
+	if (cleanupIntervalTimeInSec > 0) {
+		cleanupInterval = setInterval(() => {
+			let cutoffTime = Date.now() - cleanupIntervalTimeInSec * 1000;
+			let uris = Object.keys(languageModels);
+			for (let uri of uris) {
+				let languageModelInfo = languageModels[uri];
+				if (languageModelInfo.cTime < cutoffTime) {
+					delete languageModels[uri];
+					nModels--;
+				}
+			}
+		}, cleanupIntervalTimeInSec * 1000);
+	}
+
+	return {
+		get(document: TextDocument): T {
+			let version = document.version;
+			let languageId = document.languageId;
+			let languageModelInfo = languageModels[document.uri];
+			if (languageModelInfo && languageModelInfo.version === version && languageModelInfo.languageId === languageId) {
+				languageModelInfo.cTime = Date.now();
+				return languageModelInfo.languageModel;
+			}
+			let languageModel = parse(document);
+			languageModels[document.uri] = { languageModel, version, languageId, cTime: Date.now() };
+			if (!languageModelInfo) {
+				nModels++;
+			}
+
+			if (nModels === maxEntries) {
+				let oldestTime = Number.MAX_VALUE;
+				let oldestUri = null;
+				for (let uri in languageModels) {
+					let languageModelInfo = languageModels[uri];
+					if (languageModelInfo.cTime < oldestTime) {
+						oldestUri = uri;
+						oldestTime = languageModelInfo.cTime;
+					}
+				}
+				if (oldestUri) {
+					delete languageModels[oldestUri];
+					nModels--;
+				}
+			}
+			return languageModel;
+
+		},
+		onDocumentRemoved(document: TextDocument) {
+			let uri = document.uri;
+			if (languageModels[uri]) {
+				delete languageModels[uri];
+				nModels--;
+			}
+		},
+		dispose() {
+			if (typeof cleanupInterval !== 'undefined') {
+				clearInterval(cleanupInterval);
+				cleanupInterval = undefined;
+				languageModels = {};
+				nModels = 0;
+			}
+		}
+	};
+}

lib/vscode/extensions/css-language-features/server/src/node/cssServerMain.ts

@@ -0,0 +1,21 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { createConnection, Connection } from 'vscode-languageserver/node';
+import { formatError } from '../utils/runner';
+import { startServer } from '../cssServer';
+import { getNodeFSRequestService } from './nodeFs';
+
+// Create a connection for the server.
+const connection: Connection = createConnection();
+
+console.log = connection.console.log.bind(connection.console);
+console.error = connection.console.error.bind(connection.console);
+
+process.on('unhandledRejection', (e: any) => {
+	connection.console.error(formatError(`Unhandled exception`, e));
+});
+
+startServer(connection, { file: getNodeFSRequestService() });

lib/vscode/extensions/css-language-features/server/src/node/nodeFs.ts

@@ -0,0 +1,87 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { RequestService, getScheme } from '../requests';
+import { URI as Uri } from 'vscode-uri';
+
+import * as fs from 'fs';
+import { FileType } from 'vscode-css-languageservice';
+
+export function getNodeFSRequestService(): RequestService {
+	function ensureFileUri(location: string) {
+		if (getScheme(location) !== 'file') {
+			throw new Error('fileRequestService can only handle file URLs');
+		}
+	}
+	return {
+		getContent(location: string, encoding?: string) {
+			ensureFileUri(location);
+			return new Promise((c, e) => {
+				const uri = Uri.parse(location);
+				fs.readFile(uri.fsPath, encoding, (err, buf) => {
+					if (err) {
+						return e(err);
+					}
+					c(buf.toString());
+
+				});
+			});
+		},
+		stat(location: string) {
+			ensureFileUri(location);
+			return new Promise((c, e) => {
+				const uri = Uri.parse(location);
+				fs.stat(uri.fsPath, (err, stats) => {
+					if (err) {
+						if (err.code === 'ENOENT') {
+							return c({ type: FileType.Unknown, ctime: -1, mtime: -1, size: -1 });
+						} else {
+							return e(err);
+						}
+					}
+
+					let type = FileType.Unknown;
+					if (stats.isFile()) {
+						type = FileType.File;
+					} else if (stats.isDirectory()) {
+						type = FileType.Directory;
+					} else if (stats.isSymbolicLink()) {
+						type = FileType.SymbolicLink;
+					}
+
+					c({
+						type,
+						ctime: stats.ctime.getTime(),
+						mtime: stats.mtime.getTime(),
+						size: stats.size
+					});
+				});
+			});
+		},
+		readDirectory(location: string) {
+			ensureFileUri(location);
+			return new Promise((c, e) => {
+				const path = Uri.parse(location).fsPath;
+
+				fs.readdir(path, { withFileTypes: true }, (err, children) => {
+					if (err) {
+						return e(err);
+					}
+					c(children.map(stat => {
+						if (stat.isSymbolicLink()) {
+							return [stat.name, FileType.SymbolicLink];
+						} else if (stat.isDirectory()) {
+							return [stat.name, FileType.Directory];
+						} else if (stat.isFile()) {
+							return [stat.name, FileType.File];
+						} else {
+							return [stat.name, FileType.Unknown];
+						}
+					}));
+				});
+			});
+		}
+	};
+}

lib/vscode/extensions/css-language-features/server/src/requests.ts

@@ -0,0 +1,177 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { URI } from 'vscode-uri';
+import { RequestType, Connection } from 'vscode-languageserver';
+import { RuntimeEnvironment } from './cssServer';
+
+export namespace FsContentRequest {
+	export const type: RequestType<{ uri: string; encoding?: string; }, string, any, any> = new RequestType('fs/content');
+}
+export namespace FsStatRequest {
+	export const type: RequestType<string, FileStat, any, any> = new RequestType('fs/stat');
+}
+
+export namespace FsReadDirRequest {
+	export const type: RequestType<string, [string, FileType][], any, any> = new RequestType('fs/readDir');
+}
+
+export enum FileType {
+	/**
+	 * The file type is unknown.
+	 */
+	Unknown = 0,
+	/**
+	 * A regular file.
+	 */
+	File = 1,
+	/**
+	 * A directory.
+	 */
+	Directory = 2,
+	/**
+	 * A symbolic link to a file.
+	 */
+	SymbolicLink = 64
+}
+export interface FileStat {
+	/**
+	 * The type of the file, e.g. is a regular file, a directory, or symbolic link
+	 * to a file.
+	 */
+	type: FileType;
+	/**
+	 * The creation timestamp in milliseconds elapsed since January 1, 1970 00:00:00 UTC.
+	 */
+	ctime: number;
+	/**
+	 * The modification timestamp in milliseconds elapsed since January 1, 1970 00:00:00 UTC.
+	 */
+	mtime: number;
+	/**
+	 * The size in bytes.
+	 */
+	size: number;
+}
+
+export interface RequestService {
+	getContent(uri: string, encoding?: string): Promise<string>;
+
+	stat(uri: string): Promise<FileStat>;
+	readDirectory(uri: string): Promise<[string, FileType][]>;
+}
+
+
+export function getRequestService(handledSchemas: string[], connection: Connection, runtime: RuntimeEnvironment): RequestService {
+	const builtInHandlers: { [protocol: string]: RequestService | undefined } = {};
+	for (let protocol of handledSchemas) {
+		if (protocol === 'file') {
+			builtInHandlers[protocol] = runtime.file;
+		} else if (protocol === 'http' || protocol === 'https') {
+			builtInHandlers[protocol] = runtime.http;
+		}
+	}
+	return {
+		async stat(uri: string): Promise<FileStat> {
+			const handler = builtInHandlers[getScheme(uri)];
+			if (handler) {
+				return handler.stat(uri);
+			}
+			const res = await connection.sendRequest(FsStatRequest.type, uri.toString());
+			return res;
+		},
+		readDirectory(uri: string): Promise<[string, FileType][]> {
+			const handler = builtInHandlers[getScheme(uri)];
+			if (handler) {
+				return handler.readDirectory(uri);
+			}
+			return connection.sendRequest(FsReadDirRequest.type, uri.toString());
+		},
+		getContent(uri: string, encoding?: string): Promise<string> {
+			const handler = builtInHandlers[getScheme(uri)];
+			if (handler) {
+				return handler.getContent(uri, encoding);
+			}
+			return connection.sendRequest(FsContentRequest.type, { uri: uri.toString(), encoding });
+		}
+	};
+}
+
+export function getScheme(uri: string) {
+	return uri.substr(0, uri.indexOf(':'));
+}
+
+export function dirname(uri: string) {
+	const lastIndexOfSlash = uri.lastIndexOf('/');
+	return lastIndexOfSlash !== -1 ? uri.substr(0, lastIndexOfSlash) : '';
+}
+
+export function basename(uri: string) {
+	const lastIndexOfSlash = uri.lastIndexOf('/');
+	return uri.substr(lastIndexOfSlash + 1);
+}
+
+
+const Slash = '/'.charCodeAt(0);
+const Dot = '.'.charCodeAt(0);
+
+export function extname(uri: string) {
+	for (let i = uri.length - 1; i >= 0; i--) {
+		const ch = uri.charCodeAt(i);
+		if (ch === Dot) {
+			if (i > 0 && uri.charCodeAt(i - 1) !== Slash) {
+				return uri.substr(i);
+			} else {
+				break;
+			}
+		} else if (ch === Slash) {
+			break;
+		}
+	}
+	return '';
+}
+
+export function isAbsolutePath(path: string) {
+	return path.charCodeAt(0) === Slash;
+}
+
+export function resolvePath(uriString: string, path: string): string {
+	if (isAbsolutePath(path)) {
+		const uri = URI.parse(uriString);
+		const parts = path.split('/');
+		return uri.with({ path: normalizePath(parts) }).toString();
+	}
+	return joinPath(uriString, path);
+}
+
+export function normalizePath(parts: string[]): string {
+	const newParts: string[] = [];
+	for (const part of parts) {
+		if (part.length === 0 || part.length === 1 && part.charCodeAt(0) === Dot) {
+			// ignore
+		} else if (part.length === 2 && part.charCodeAt(0) === Dot && part.charCodeAt(1) === Dot) {
+			newParts.pop();
+		} else {
+			newParts.push(part);
+		}
+	}
+	if (parts.length > 1 && parts[parts.length - 1].length === 0) {
+		newParts.push('');
+	}
+	let res = newParts.join('/');
+	if (parts[0].length === 0) {
+		res = '/' + res;
+	}
+	return res;
+}
+
+export function joinPath(uriString: string, ...paths: string[]): string {
+	const uri = URI.parse(uriString);
+	const parts = uri.path.split('/');
+	for (let path of paths) {
+		parts.push(...path.split('/'));
+	}
+	return uri.with({ path: normalizePath(parts) }).toString();
+}

lib/vscode/extensions/css-language-features/server/src/test/completion.test.ts

@@ -0,0 +1,204 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import 'mocha';
+import * as assert from 'assert';
+import * as path from 'path';
+import { URI } from 'vscode-uri';
+import { TextDocument, CompletionList, TextEdit } from 'vscode-languageserver-types';
+import { WorkspaceFolder } from 'vscode-languageserver-protocol';
+import { getCSSLanguageService, LanguageServiceOptions, getSCSSLanguageService } from 'vscode-css-languageservice';
+import { getNodeFSRequestService } from '../node/nodeFs';
+import { getDocumentContext } from '../utils/documentContext';
+
+export interface ItemDescription {
+	label: string;
+	resultText?: string;
+}
+
+suite('Completions', () => {
+
+	let assertCompletion = function (completions: CompletionList, expected: ItemDescription, document: TextDocument, _offset: number) {
+		let matches = completions.items.filter(completion => {
+			return completion.label === expected.label;
+		});
+
+		assert.equal(matches.length, 1, `${expected.label} should only existing once: Actual: ${completions.items.map(c => c.label).join(', ')}`);
+		let match = matches[0];
+		if (expected.resultText && TextEdit.is(match.textEdit)) {
+			assert.equal(TextDocument.applyEdits(document, [match.textEdit]), expected.resultText);
+		}
+	};
+
+	async function assertCompletions(value: string, expected: { count?: number, items?: ItemDescription[] }, testUri: string, workspaceFolders?: WorkspaceFolder[], lang: string = 'css'): Promise<any> {
+		const offset = value.indexOf('|');
+		value = value.substr(0, offset) + value.substr(offset + 1);
+
+		const document = TextDocument.create(testUri, lang, 0, value);
+		const position = document.positionAt(offset);
+
+		if (!workspaceFolders) {
+			workspaceFolders = [{ name: 'x', uri: testUri.substr(0, testUri.lastIndexOf('/')) }];
+		}
+
+		const lsOptions: LanguageServiceOptions = { fileSystemProvider: getNodeFSRequestService() };
+		const cssLanguageService = lang === 'scss' ? getSCSSLanguageService(lsOptions) : getCSSLanguageService(lsOptions);
+
+		const context = getDocumentContext(testUri, workspaceFolders);
+		const stylesheet = cssLanguageService.parseStylesheet(document);
+		let list = await cssLanguageService.doComplete2(document, position, stylesheet, context);
+
+		if (expected.count) {
+			assert.equal(list.items.length, expected.count);
+		}
+		if (expected.items) {
+			for (let item of expected.items) {
+				assertCompletion(list, item, document, offset);
+			}
+		}
+	}
+
+	test('CSS url() Path completion', async function () {
+		let testUri = URI.file(path.resolve(__dirname, '../../test/pathCompletionFixtures/about/about.css')).toString();
+		let folders = [{ name: 'x', uri: URI.file(path.resolve(__dirname, '../../test')).toString() }];
+
+		await assertCompletions('html { background-image: url("./|")', {
+			items: [
+				{ label: 'about.html', resultText: 'html { background-image: url("./about.html")' }
+			]
+		}, testUri, folders);
+
+		await assertCompletions(`html { background-image: url('../|')`, {
+			items: [
+				{ label: 'about/', resultText: `html { background-image: url('../about/')` },
+				{ label: 'index.html', resultText: `html { background-image: url('../index.html')` },
+				{ label: 'src/', resultText: `html { background-image: url('../src/')` }
+			]
+		}, testUri, folders);
+
+		await assertCompletions(`html { background-image: url('../src/a|')`, {
+			items: [
+				{ label: 'feature.js', resultText: `html { background-image: url('../src/feature.js')` },
+				{ label: 'data/', resultText: `html { background-image: url('../src/data/')` },
+				{ label: 'test.js', resultText: `html { background-image: url('../src/test.js')` }
+			]
+		}, testUri, folders);
+
+		await assertCompletions(`html { background-image: url('../src/data/f|.asar')`, {
+			items: [
+				{ label: 'foo.asar', resultText: `html { background-image: url('../src/data/foo.asar')` }
+			]
+		}, testUri, folders);
+
+		await assertCompletions(`html { background-image: url('|')`, {
+			items: [
+				{ label: 'about.html', resultText: `html { background-image: url('about.html')` },
+			]
+		}, testUri, folders);
+
+		await assertCompletions(`html { background-image: url('/|')`, {
+			items: [
+				{ label: 'pathCompletionFixtures/', resultText: `html { background-image: url('/pathCompletionFixtures/')` }
+			]
+		}, testUri, folders);
+
+		await assertCompletions(`html { background-image: url('/pathCompletionFixtures/|')`, {
+			items: [
+				{ label: 'about/', resultText: `html { background-image: url('/pathCompletionFixtures/about/')` },
+				{ label: 'index.html', resultText: `html { background-image: url('/pathCompletionFixtures/index.html')` },
+				{ label: 'src/', resultText: `html { background-image: url('/pathCompletionFixtures/src/')` }
+			]
+		}, testUri, folders);
+
+		await assertCompletions(`html { background-image: url("/|")`, {
+			items: [
+				{ label: 'pathCompletionFixtures/', resultText: `html { background-image: url("/pathCompletionFixtures/")` }
+			]
+		}, testUri, folders);
+	});
+
+	test('CSS url() Path Completion - Unquoted url', async function () {
+		let testUri = URI.file(path.resolve(__dirname, '../../test/pathCompletionFixtures/about/about.css')).toString();
+		let folders = [{ name: 'x', uri: URI.file(path.resolve(__dirname, '../../test')).toString() }];
+
+		await assertCompletions('html { background-image: url(./|)', {
+			items: [
+				{ label: 'about.html', resultText: 'html { background-image: url(./about.html)' }
+			]
+		}, testUri, folders);
+
+		await assertCompletions('html { background-image: url(./a|)', {
+			items: [
+				{ label: 'about.html', resultText: 'html { background-image: url(./about.html)' }
+			]
+		}, testUri, folders);
+
+		await assertCompletions('html { background-image: url(../|src/)', {
+			items: [
+				{ label: 'about/', resultText: 'html { background-image: url(../about/)' }
+			]
+		}, testUri, folders);
+
+		await assertCompletions('html { background-image: url(../s|rc/)', {
+			items: [
+				{ label: 'about/', resultText: 'html { background-image: url(../about/)' }
+			]
+		}, testUri, folders);
+	});
+
+	test('CSS @import Path completion', async function () {
+		let testUri = URI.file(path.resolve(__dirname, '../../test/pathCompletionFixtures/about/about.css')).toString();
+		let folders = [{ name: 'x', uri: URI.file(path.resolve(__dirname, '../../test')).toString() }];
+
+		await assertCompletions(`@import './|'`, {
+			items: [
+				{ label: 'about.html', resultText: `@import './about.html'` },
+			]
+		}, testUri, folders);
+
+		await assertCompletions(`@import '../|'`, {
+			items: [
+				{ label: 'about/', resultText: `@import '../about/'` },
+				{ label: 'scss/', resultText: `@import '../scss/'` },
+				{ label: 'index.html', resultText: `@import '../index.html'` },
+				{ label: 'src/', resultText: `@import '../src/'` }
+			]
+		}, testUri, folders);
+	});
+
+	/**
+	 * For SCSS, `@import 'foo';` can be used for importing partial file `_foo.scss`
+	 */
+	test('SCSS @import Path completion', async function () {
+		let testCSSUri = URI.file(path.resolve(__dirname, '../../test/pathCompletionFixtures/about/about.css')).toString();
+		let folders = [{ name: 'x', uri: URI.file(path.resolve(__dirname, '../../test')).toString() }];
+
+		/**
+		 * We are in a CSS file, so no special treatment for SCSS partial files
+		*/
+		await assertCompletions(`@import '../scss/|'`, {
+			items: [
+				{ label: 'main.scss', resultText: `@import '../scss/main.scss'` },
+				{ label: '_foo.scss', resultText: `@import '../scss/_foo.scss'` }
+			]
+		}, testCSSUri, folders);
+
+		let testSCSSUri = URI.file(path.resolve(__dirname, '../../test/pathCompletionFixtures/scss/main.scss')).toString();
+		await assertCompletions(`@import './|'`, {
+			items: [
+				{ label: '_foo.scss', resultText: `@import './foo'` }
+			]
+		}, testSCSSUri, folders, 'scss');
+	});
+
+	test('Completion should ignore files/folders starting with dot', async function () {
+		let testUri = URI.file(path.resolve(__dirname, '../../test/pathCompletionFixtures/about/about.css')).toString();
+		let folders = [{ name: 'x', uri: URI.file(path.resolve(__dirname, '../../test')).toString() }];
+
+		await assertCompletions('html { background-image: url("../|")', {
+			count: 4
+		}, testUri, folders);
+
+	});
+});

lib/vscode/extensions/css-language-features/server/src/test/links.test.ts

@@ -0,0 +1,90 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import 'mocha';
+import * as assert from 'assert';
+import { URI }  from 'vscode-uri';
+import { resolve } from 'path';
+import { TextDocument, DocumentLink } from 'vscode-languageserver-types';
+import { WorkspaceFolder } from 'vscode-languageserver-protocol';
+import { getCSSLanguageService } from 'vscode-css-languageservice';
+import { getDocumentContext } from '../utils/documentContext';
+import { getNodeFSRequestService } from '../node/nodeFs';
+
+export interface ItemDescription {
+	offset: number;
+	value: string;
+	target: string;
+}
+
+suite('Links', () => {
+	const cssLanguageService = getCSSLanguageService({ fileSystemProvider: getNodeFSRequestService() });
+
+	let assertLink = function (links: DocumentLink[], expected: ItemDescription, document: TextDocument) {
+		let matches = links.filter(link => {
+			return document.offsetAt(link.range.start) === expected.offset;
+		});
+
+		assert.equal(matches.length, 1, `${expected.offset} should only existing once: Actual: ${links.map(l => document.offsetAt(l.range.start)).join(', ')}`);
+		let match = matches[0];
+		assert.equal(document.getText(match.range), expected.value);
+		assert.equal(match.target, expected.target);
+	};
+
+	async function assertLinks(value: string, expected: ItemDescription[], testUri: string, workspaceFolders?: WorkspaceFolder[], lang: string = 'css'): Promise<void> {
+		const offset = value.indexOf('|');
+		value = value.substr(0, offset) + value.substr(offset + 1);
+
+		const document = TextDocument.create(testUri, lang, 0, value);
+
+		if (!workspaceFolders) {
+			workspaceFolders = [{ name: 'x', uri: testUri.substr(0, testUri.lastIndexOf('/')) }];
+		}
+
+		const context = getDocumentContext(testUri, workspaceFolders);
+
+		const stylesheet = cssLanguageService.parseStylesheet(document);
+		let links = await cssLanguageService.findDocumentLinks2(document, stylesheet, context)!;
+
+		assert.equal(links.length, expected.length);
+
+		for (let item of expected) {
+			assertLink(links, item, document);
+		}
+	}
+
+	function getTestResource(path: string) {
+		return URI.file(resolve(__dirname, '../../test/linksTestFixtures', path)).toString();
+	}
+
+	test('url links', async function () {
+
+		let testUri = getTestResource('about.css');
+		let folders = [{ name: 'x', uri: getTestResource('') }];
+
+		await assertLinks('html { background-image: url("hello.html|")',
+			[{ offset: 29, value: '"hello.html"', target: getTestResource('hello.html') }], testUri, folders
+		);
+	});
+
+	test('node module resolving', async function () {
+
+		let testUri = getTestResource('about.css');
+		let folders = [{ name: 'x', uri: getTestResource('') }];
+
+		await assertLinks('html { background-image: url("~foo/hello.html|")',
+			[{ offset: 29, value: '"~foo/hello.html"', target: getTestResource('node_modules/foo/hello.html') }], testUri, folders
+		);
+	});
+
+	test('node module subfolder resolving', async function () {
+
+		let testUri = getTestResource('subdir/about.css');
+		let folders = [{ name: 'x', uri: getTestResource('') }];
+
+		await assertLinks('html { background-image: url("~foo/hello.html|")',
+			[{ offset: 29, value: '"~foo/hello.html"', target: getTestResource('node_modules/foo/hello.html') }], testUri, folders
+		);
+	});
+});

lib/vscode/extensions/css-language-features/server/src/test/requests.test.ts

@@ -0,0 +1,62 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import 'mocha';
+import * as assert from 'assert';
+import { joinPath, normalizePath, resolvePath, extname } from '../requests';
+
+suite('requests', () => {
+	test('join', async function () {
+		assert.equal(joinPath('foo://a/foo/bar', 'x'), 'foo://a/foo/bar/x');
+		assert.equal(joinPath('foo://a/foo/bar/', 'x'), 'foo://a/foo/bar/x');
+		assert.equal(joinPath('foo://a/foo/bar/', '/x'), 'foo://a/foo/bar/x');
+		assert.equal(joinPath('foo://a/foo/bar/', 'x/'), 'foo://a/foo/bar/x/');
+		assert.equal(joinPath('foo://a/foo/bar/', 'x', 'y'), 'foo://a/foo/bar/x/y');
+		assert.equal(joinPath('foo://a/foo/bar/', 'x/', '/y'), 'foo://a/foo/bar/x/y');
+		assert.equal(joinPath('foo://a/foo/bar/', '.', '/y'), 'foo://a/foo/bar/y');
+		assert.equal(joinPath('foo://a/foo/bar/', 'x/y/z', '..'), 'foo://a/foo/bar/x/y');
+	});
+
+	test('resolve', async function () {
+		assert.equal(resolvePath('foo://a/foo/bar', 'x'), 'foo://a/foo/bar/x');
+		assert.equal(resolvePath('foo://a/foo/bar/', 'x'), 'foo://a/foo/bar/x');
+		assert.equal(resolvePath('foo://a/foo/bar/', '/x'), 'foo://a/x');
+		assert.equal(resolvePath('foo://a/foo/bar/', 'x/'), 'foo://a/foo/bar/x/');
+	});
+
+	test('normalize', async function () {
+		function assertNormalize(path: string, expected: string) {
+			assert.equal(normalizePath(path.split('/')), expected, path);
+		}
+		assertNormalize('a', 'a');
+		assertNormalize('/a', '/a');
+		assertNormalize('a/', 'a/');
+		assertNormalize('a/b', 'a/b');
+		assertNormalize('/a/foo/bar/x', '/a/foo/bar/x');
+		assertNormalize('/a/foo/bar//x', '/a/foo/bar/x');
+		assertNormalize('/a/foo/bar///x', '/a/foo/bar/x');
+		assertNormalize('/a/foo/bar/x/', '/a/foo/bar/x/');
+		assertNormalize('a/foo/bar/x/', 'a/foo/bar/x/');
+		assertNormalize('a/foo/bar/x//', 'a/foo/bar/x/');
+		assertNormalize('//a/foo/bar/x//', '/a/foo/bar/x/');
+		assertNormalize('a/.', 'a');
+		assertNormalize('a/./b', 'a/b');
+		assertNormalize('a/././b', 'a/b');
+		assertNormalize('a/n/../b', 'a/b');
+		assertNormalize('a/n/../', 'a/');
+		assertNormalize('a/n/../', 'a/');
+		assertNormalize('/a/n/../..', '/');
+		assertNormalize('..', '');
+		assertNormalize('/..', '/');
+	});
+
+	test('extname', async function () {
+		function assertExtName(input: string, expected: string) {
+			assert.equal(extname(input), expected, input);
+		}
+		assertExtName('foo://a/foo/bar', '');
+		assertExtName('foo://a/foo/bar.foo', '.foo');
+		assertExtName('foo://a/foo/.foo', '');
+	});
+});

lib/vscode/extensions/css-language-features/server/src/utils/documentContext.ts

@@ -0,0 +1,38 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { DocumentContext } from 'vscode-css-languageservice';
+import { endsWith, startsWith } from '../utils/strings';
+import { WorkspaceFolder } from 'vscode-languageserver';
+import { resolvePath } from '../requests';
+
+export function getDocumentContext(documentUri: string, workspaceFolders: WorkspaceFolder[]): DocumentContext {
+	function getRootFolder(): string | undefined {
+		for (let folder of workspaceFolders) {
+			let folderURI = folder.uri;
+			if (!endsWith(folderURI, '/')) {
+				folderURI = folderURI + '/';
+			}
+			if (startsWith(documentUri, folderURI)) {
+				return folderURI;
+			}
+		}
+		return undefined;
+	}
+
+	return {
+		resolveReference: (ref: string, base = documentUri) => {
+			if (ref[0] === '/') { // resolve absolute path against the current workspace folder
+				let folderUri = getRootFolder();
+				if (folderUri) {
+					return folderUri + ref.substr(1);
+				}
+			}
+			base = base.substr(0, base.lastIndexOf('/') + 1);
+			return resolvePath(base, ref);
+		},
+	};
+}
+

lib/vscode/extensions/css-language-features/server/src/utils/runner.ts

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ResponseError, ErrorCodes, CancellationToken } from 'vscode-languageserver';
+
+export function formatError(message: string, err: any): string {
+	if (err instanceof Error) {
+		let error = <Error>err;
+		return `${message}: ${error.message}\n${error.stack}`;
+	} else if (typeof err === 'string') {
+		return `${message}: ${err}`;
+	} else if (err) {
+		return `${message}: ${err.toString()}`;
+	}
+	return message;
+}
+
+export function runSafeAsync<T>(func: () => Thenable<T>, errorVal: T, errorMessage: string, token: CancellationToken): Thenable<T | ResponseError<any>> {
+	return new Promise<T | ResponseError<any>>((resolve) => {
+		setImmediate(() => {
+			if (token.isCancellationRequested) {
+				resolve(cancelValue());
+			}
+			return func().then(result => {
+				if (token.isCancellationRequested) {
+					resolve(cancelValue());
+					return;
+				} else {
+					resolve(result);
+				}
+			}, e => {
+				console.error(formatError(errorMessage, e));
+				resolve(errorVal);
+			});
+		});
+	});
+}
+
+function cancelValue<E>() {
+	return new ResponseError<E>(ErrorCodes.RequestCancelled, 'Request cancelled');
+}

lib/vscode/extensions/css-language-features/server/src/utils/strings.ts

@@ -0,0 +1,32 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export function startsWith(haystack: string, needle: string): boolean {
+	if (haystack.length < needle.length) {
+		return false;
+	}
+
+	for (let i = 0; i < needle.length; i++) {
+		if (haystack[i] !== needle[i]) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+/**
+ * Determines if haystack ends with needle.
+ */
+export function endsWith(haystack: string, needle: string): boolean {
+	let diff = haystack.length - needle.length;
+	if (diff > 0) {
+		return haystack.lastIndexOf(needle) === diff;
+	} else if (diff === 0) {
+		return haystack === needle;
+	} else {
+		return false;
+	}
+}