Merge from vscode 4d91d96e5e121b38d33508cdef17868bab255eae

extensions/markdown-language-features/src/features/preview.ts

@@ -227,10 +227,10 @@ class MarkdownPreview extends Disposable implements WebviewResourceProvider {
 	}
 
 	private get iconPath() {
-		const root = path.join(this._contributionProvider.extensionPath, 'media');
+		const root = vscode.Uri.joinPath(this._contributionProvider.extensionUri, 'media');
 		return {
-			light: vscode.Uri.file(path.join(root, 'preview-light.svg')),
-			dark: vscode.Uri.file(path.join(root, 'preview-dark.svg'))
+			light: vscode.Uri.joinPath(root, 'preview-light.svg'),
+			dark: vscode.Uri.joinPath(root, 'preview-dark.svg'),
 		};
 	}
 

extensions/markdown-language-features/src/features/previewContentProvider.ts

@@ -111,7 +111,7 @@ export class MarkdownContentProvider {
 
 	private extensionResourcePath(resourceProvider: WebviewResourceProvider, mediaFile: string): string {
 		const webviewResource = resourceProvider.asWebviewUri(
-			vscode.Uri.file(this.context.asAbsolutePath(path.join('media', mediaFile))));
+			vscode.Uri.joinPath(this.context.extensionUri, 'media', mediaFile));
 		return webviewResource.toString();
 	}
 
@@ -132,7 +132,7 @@ export class MarkdownContentProvider {
 		// Use a workspace relative path if there is a workspace
 		const root = vscode.workspace.getWorkspaceFolder(resource);
 		if (root) {
-			return resourceProvider.asWebviewUri(vscode.Uri.file(path.join(root.uri.fsPath, href))).toString();
+			return resourceProvider.asWebviewUri(vscode.Uri.joinPath(root.uri, href)).toString();
 		}
 
 		// Otherwise look relative to the markdown file

extensions/markdown-language-features/src/markdownEngine.ts

@@ -3,14 +3,14 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as crypto from 'crypto';
-import * as path from 'path';
 import { MarkdownIt, Token } from 'markdown-it';
+import * as path from 'path';
 import * as vscode from 'vscode';
 import { MarkdownContributionProvider as MarkdownContributionProvider } from './markdownExtensions';
 import { Slugifier } from './slugify';
 import { SkinnyTextDocument } from './tableOfContentsProvider';
-import { MarkdownFileExtensions, Schemes, isOfScheme } from './util/links';
+import { hash } from './util/hash';
+import { isOfScheme, MarkdownFileExtensions, Schemes } from './util/links';
 
 const UNICODE_NEWLINE_REGEX = /\u2028|\u2029/g;
 
@@ -204,9 +204,7 @@ export class MarkdownEngine {
 
 			const src = token.attrGet('src');
 			if (src) {
-				const hash = crypto.createHash('sha256');
-				hash.update(src);
-				const imgHash = hash.digest('hex');
+				const imgHash = hash(src);
 				token.attrSet('id', `image-hash-${imgHash}`);
 			}
 
@@ -249,7 +247,7 @@ export class MarkdownEngine {
 					if (uri.path[0] === '/') {
 						const root = vscode.workspace.getWorkspaceFolder(this.currentDocument!);
 						if (root) {
-							const fileUri = vscode.Uri.file(path.join(root.uri.fsPath, uri.fsPath));
+							const fileUri = vscode.Uri.joinPath(root.uri, uri.fsPath);
 							uri = fileUri.with({
 								scheme: uri.scheme,
 								fragment: uri.fragment,

extensions/markdown-language-features/src/markdownExtensions.ts

@@ -4,12 +4,11 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import * as path from 'path';
-import { Disposable } from './util/dispose';
 import * as arrays from './util/arrays';
+import { Disposable } from './util/dispose';
 
 const resolveExtensionResource = (extension: vscode.Extension<any>, resourcePath: string): vscode.Uri => {
-	return vscode.Uri.file(path.join(extension.extensionPath, resourcePath));
+	return vscode.Uri.joinPath(extension.extensionUri, resourcePath);
 };
 
 const resolveExtensionResources = (extension: vscode.Extension<any>, resourcePaths: unknown): vscode.Uri[] => {
@@ -114,7 +113,8 @@ export namespace MarkdownContributions {
 }
 
 export interface MarkdownContributionProvider {
-	readonly extensionPath: string;
+	readonly extensionUri: vscode.Uri;
+
 	readonly contributions: MarkdownContributions;
 	readonly onContributionsChanged: vscode.Event<this>;
 
@@ -125,7 +125,7 @@ class VSCodeExtensionMarkdownContributionProvider extends Disposable implements
 	private _contributions?: MarkdownContributions;
 
 	public constructor(
-		public readonly extensionPath: string,
+		private readonly _extensionContext: vscode.ExtensionContext,
 	) {
 		super();
 
@@ -139,6 +139,8 @@ class VSCodeExtensionMarkdownContributionProvider extends Disposable implements
 		}, undefined, this._disposables);
 	}
 
+	public get extensionUri() { return this._extensionContext.extensionUri; }
+
 	private readonly _onContributionsChanged = this._register(new vscode.EventEmitter<this>());
 	public readonly onContributionsChanged = this._onContributionsChanged.event;
 
@@ -157,5 +159,5 @@ class VSCodeExtensionMarkdownContributionProvider extends Disposable implements
 }
 
 export function getMarkdownExtensionContributions(context: vscode.ExtensionContext): MarkdownContributionProvider {
-	return new VSCodeExtensionMarkdownContributionProvider(context.extensionPath);
-}
+	return new VSCodeExtensionMarkdownContributionProvider(context);
+}

extensions/markdown-language-features/src/test/engine.ts

@@ -10,7 +10,7 @@ import { githubSlugifier } from '../slugify';
 import { Disposable } from '../util/dispose';
 
 const emptyContributions = new class extends Disposable implements MarkdownContributionProvider {
-	readonly extensionPath = '';
+	readonly extensionUri = vscode.Uri.file('/');
 	readonly contributions = MarkdownContributions.Empty;
 	readonly onContributionsChanged = this._register(new vscode.EventEmitter<this>()).event;
 };

extensions/markdown-language-features/src/util/hash.ts

@@ -0,0 +1,58 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/**
+ * Return a hash value for an object.
+ */
+export function hash(obj: any, hashVal = 0): number {
+	switch (typeof obj) {
+		case 'object':
+			if (obj === null) {
+				return numberHash(349, hashVal);
+			} else if (Array.isArray(obj)) {
+				return arrayHash(obj, hashVal);
+			}
+			return objectHash(obj, hashVal);
+		case 'string':
+			return stringHash(obj, hashVal);
+		case 'boolean':
+			return booleanHash(obj, hashVal);
+		case 'number':
+			return numberHash(obj, hashVal);
+		case 'undefined':
+			return 937 * 31;
+		default:
+			return numberHash(obj, 617);
+	}
+}
+
+function numberHash(val: number, initialHashVal: number): number {
+	return (((initialHashVal << 5) - initialHashVal) + val) | 0;  // hashVal * 31 + ch, keep as int32
+}
+
+function booleanHash(b: boolean, initialHashVal: number): number {
+	return numberHash(b ? 433 : 863, initialHashVal);
+}
+
+function stringHash(s: string, hashVal: number) {
+	hashVal = numberHash(149417, hashVal);
+	for (let i = 0, length = s.length; i < length; i++) {
+		hashVal = numberHash(s.charCodeAt(i), hashVal);
+	}
+	return hashVal;
+}
+
+function arrayHash(arr: any[], initialHashVal: number): number {
+	initialHashVal = numberHash(104579, initialHashVal);
+	return arr.reduce((hashVal, item) => hash(item, hashVal), initialHashVal);
+}
+
+function objectHash(obj: any, initialHashVal: number): number {
+	initialHashVal = numberHash(181387, initialHashVal);
+	return Object.keys(obj).sort().reduce((hashVal, key) => {
+		hashVal = stringHash(key, hashVal);
+		return hash(obj[key], hashVal);
+	}, initialHashVal);
+}