Merge from master

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

@@ -6,8 +6,10 @@
 import { MarkdownIt, Token } from 'markdown-it';
 import * as path from 'path';
 import * as vscode from 'vscode';
+import * as crypto from 'crypto';
 import { MarkdownContributions } from './markdownExtensions';
 import { Slugifier } from './slugify';
+import { getUriForLinkWithKnownExternalScheme } from './util/links';
 
 const FrontMatterRegex = /^---\s*[^]*?(-{3}|\.{3})\s*/;
 
@@ -15,8 +17,8 @@ export class MarkdownEngine {
 	private md?: MarkdownIt;
 
 	private firstLine?: number;
-
 	private currentDocument?: vscode.Uri;
+	private _slugCount = new Map<string, number>();
 
 	public constructor(
 		private readonly extensionPreviewResourceProvider: MarkdownContributions,
@@ -34,14 +36,19 @@ export class MarkdownEngine {
 	private async getEngine(resource: vscode.Uri): Promise<MarkdownIt> {
 		if (!this.md) {
 			const hljs = await import('highlight.js');
-			const mdnh = await import('markdown-it-named-headers');
 			this.md = (await import('markdown-it'))({
 				html: true,
-				highlight: (str: string, lang: string) => {
+				highlight: (str: string, lang?: string) => {
 					// Workaround for highlight not supporting tsx: https://github.com/isagalaev/highlight.js/issues/1155
 					if (lang && ['tsx', 'typescriptreact'].indexOf(lang.toLocaleLowerCase()) >= 0) {
 						lang = 'jsx';
 					}
+					if (lang && lang.toLocaleLowerCase() === 'json5') {
+						lang = 'json';
+					}
+					if (lang && lang.toLocaleLowerCase() === 'c#') {
+						lang = 'cs';
+					}
 					if (lang && hljs.getLanguage(lang)) {
 						try {
 							return `<div>${hljs.highlight(lang, str, true).value}</div>`;
@@ -49,8 +56,6 @@ export class MarkdownEngine {
 					}
 					return `<code><div>${this.md!.utils.escapeHtml(str)}</div></code>`;
 				}
-			}).use(mdnh, {
-				slugify: (header: string) => this.slugifier.fromHeading(header).value
 			});
 
 			for (const plugin of this.extensionPreviewResourceProvider.markdownItPlugins) {
@@ -61,10 +66,12 @@ export class MarkdownEngine {
 				this.addLineNumberRenderer(this.md, renderName);
 			}
 
+			this.addImageStabilizer(this.md);
 			this.addFencedRenderer(this.md);
 
 			this.addLinkNormalizer(this.md);
 			this.addLinkValidator(this.md);
+			this.addNamedHeaders(this.md);
 		}
 
 		const config = vscode.workspace.getConfiguration('markdown', resource);
@@ -101,18 +108,24 @@ export class MarkdownEngine {
 		}
 		this.currentDocument = document;
 		this.firstLine = offset;
+		this._slugCount = new Map<string, number>();
+
 		const engine = await this.getEngine(document);
 		return engine.render(text);
 	}
 
 	public async parse(document: vscode.Uri, source: string): Promise<Token[]> {
+		const UNICODE_NEWLINE_REGEX = /\u2028|\u2029/g;
 		const { text, offset } = this.stripFrontmatter(source);
 		this.currentDocument = document;
+		this._slugCount = new Map<string, number>();
+
 		const engine = await this.getEngine(document);
 
-		return engine.parse(text, {}).map(token => {
+		return engine.parse(text.replace(UNICODE_NEWLINE_REGEX, ''), {}).map(token => {
 			if (token.map) {
 				token.map[0] += offset;
+				token.map[1] += offset;
 			}
 			return token;
 		});
@@ -135,6 +148,28 @@ export class MarkdownEngine {
 		};
 	}
 
+	private addImageStabilizer(md: any): void {
+		const original = md.renderer.rules.image;
+		md.renderer.rules.image = (tokens: any, idx: number, options: any, env: any, self: any) => {
+			const token = tokens[idx];
+			token.attrJoin('class', 'loading');
+
+			const src = token.attrGet('src');
+			if (src) {
+				const hash = crypto.createHash('sha256');
+				hash.update(src);
+				const imgHash = hash.digest('hex');
+				token.attrSet('id', `image-hash-${imgHash}`);
+			}
+
+			if (original) {
+				return original(tokens, idx, options, env, self);
+			} else {
+				return self.renderToken(tokens, idx, options, env, self);
+			}
+		};
+	}
+
 	private addFencedRenderer(md: any): void {
 		const original = md.renderer.rules['fenced'];
 		md.renderer.rules['fenced'] = (tokens: any, idx: number, options: any, env: any, self: any) => {
@@ -151,8 +186,18 @@ export class MarkdownEngine {
 		const normalizeLink = md.normalizeLink;
 		md.normalizeLink = (link: string) => {
 			try {
-				let uri = vscode.Uri.parse(link);
-				if (!uri.scheme && uri.path) {
+				const externalSchemeUri = getUriForLinkWithKnownExternalScheme(link);
+				if (externalSchemeUri) {
+					// set true to skip encoding
+					return normalizeLink(externalSchemeUri.toString(true));
+				}
+
+
+				// Assume it must be an relative or absolute file path
+				// Use a fake scheme to avoid parse warnings
+				let uri = vscode.Uri.parse(`vscode-resource:${link}`);
+
+				if (uri.path) {
 					// Assume it must be a file
 					const fragment = uri.fragment;
 					if (uri.path[0] === '/') {
@@ -170,10 +215,8 @@ export class MarkdownEngine {
 						});
 					}
 					return normalizeLink(uri.with({ scheme: 'vscode-resource' }).toString(true));
-				} else if (!uri.scheme && !uri.path && uri.fragment) {
-					return normalizeLink(uri.with({
-						fragment: this.slugifier.fromHeading(uri.fragment).value
-					}).toString(true));
+				} else if (!uri.path && uri.fragment) {
+					return `#${this.slugifier.fromHeading(uri.fragment).value}`;
 				}
 			} catch (e) {
 				// noop
@@ -189,4 +232,29 @@ export class MarkdownEngine {
 			return validateLink(link) || link.indexOf('file:') === 0;
 		};
 	}
+
+	private addNamedHeaders(md: any): void {
+		const original = md.renderer.rules.heading_open;
+		md.renderer.rules.heading_open = (tokens: any, idx: number, options: any, env: any, self: any) => {
+			const title = tokens[idx + 1].children.reduce((acc: string, t: any) => acc + t.content, '');
+			let slug = this.slugifier.fromHeading(title);
+
+			if (this._slugCount.has(slug.value)) {
+				const count = this._slugCount.get(slug.value)!;
+				this._slugCount.set(slug.value, count + 1);
+				slug = this.slugifier.fromHeading(slug.value + '-' + (count + 1));
+			} else {
+				this._slugCount.set(slug.value, 0);
+			}
+
+			tokens[idx].attrs = tokens[idx].attrs || [];
+			tokens[idx].attrs.push(['id', slug.value]);
+
+			if (original) {
+				return original(tokens, idx, options, env, self);
+			} else {
+				return self.renderToken(tokens, idx, options, env, self);
+			}
+		};
+	}
 }