build(site): [SITE-07] reproduce Monaco CSS HTML and JSON workers

refactor/baselines/site-vendor/monaco-languages/monaco-css-scripts-bundle.js.txt

@@ -0,0 +1,86 @@
+const requirejs = require('requirejs');
+const path = require('path');
+const fs = require('fs');
+const Terser = require('terser');
+const helpers = require('monaco-plugin-helpers');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+
+const sha1 = helpers.getGitVersion(REPO_ROOT);
+const semver = require('../../package.json').version;
+const headerVersion = semver + '(' + sha1 + ')';
+
+const BUNDLED_FILE_HEADER = [
+	'/*!-----------------------------------------------------------------------------',
+	' * Copyright (c) Microsoft Corporation. All rights reserved.',
+	' * monaco-css version: ' + headerVersion,
+	' * Released under the MIT license',
+	' * https://github.com/Microsoft/monaco-css/blob/master/LICENSE.md',
+	' *-----------------------------------------------------------------------------*/',
+	''
+].join('\n');
+
+bundleOne('monaco.contribution');
+bundleOne('cssMode', ['vs/language/css/monaco.contribution']);
+bundleOne('cssWorker');
+
+function bundleOne(moduleId, exclude) {
+	requirejs.optimize(
+		{
+			baseUrl: 'out/amd/',
+			name: 'vs/language/css/' + moduleId,
+			out: 'release/dev/' + moduleId + '.js',
+			exclude: exclude,
+			paths: {
+				'vs/language/css': REPO_ROOT + '/monaco-css/out/amd',
+				'vs/language/css/fillers/monaco-editor-core':
+					REPO_ROOT + '/monaco-css/out/amd/fillers/monaco-editor-core-amd'
+			},
+			optimize: 'none',
+			packages: [
+				{
+					name: 'vscode-css-languageservice',
+					location: path.join(REPO_ROOT, 'node_modules/vscode-css-languageservice/lib/umd'),
+					main: 'cssLanguageService'
+				},
+				{
+					name: 'vscode-languageserver-types',
+					location: path.join(REPO_ROOT, 'node_modules/vscode-languageserver-types/lib/umd'),
+					main: 'main'
+				},
+				{
+					name: 'vscode-languageserver-textdocument',
+					location: path.join(REPO_ROOT, 'node_modules/vscode-languageserver-textdocument/lib/umd'),
+					main: 'main'
+				},
+				{
+					name: 'vscode-uri',
+					location: path.join(REPO_ROOT, 'node_modules/vscode-uri/lib/umd'),
+					main: 'index'
+				},
+				{
+					name: 'vscode-nls',
+					location: path.join(REPO_ROOT, 'monaco-css/out/amd/fillers'),
+					main: 'vscode-nls'
+				}
+			]
+		},
+		async function (buildResponse) {
+			const devFilePath = path.join(REPO_ROOT, 'monaco-css/release/dev/' + moduleId + '.js');
+			const minFilePath = path.join(REPO_ROOT, 'monaco-css/release/min/' + moduleId + '.js');
+			const fileContents = fs.readFileSync(devFilePath).toString();
+			console.log();
+			console.log(`Minifying ${devFilePath}...`);
+			const result = await Terser.minify(fileContents, {
+				output: {
+					comments: 'some'
+				}
+			});
+			console.log(`Done minifying ${devFilePath}.`);
+			try {
+				fs.mkdirSync(path.join(REPO_ROOT, 'monaco-css/release/min'));
+			} catch (err) {}
+			fs.writeFileSync(minFilePath, BUNDLED_FILE_HEADER + result.code);
+		}
+	);
+}

refactor/baselines/site-vendor/monaco-languages/monaco-css-src-cssWorker.ts.txt

@@ -0,0 +1,184 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import type { worker } from './fillers/monaco-editor-core';
+import * as cssService from 'vscode-css-languageservice';
+import { Options } from './monaco.contribution';
+
+export class CSSWorker {
+	// --- model sync -----------------------
+
+	private _ctx: worker.IWorkerContext;
+	private _languageService: cssService.LanguageService;
+	private _languageSettings: cssService.LanguageSettings;
+	private _languageId: string;
+
+	constructor(ctx: worker.IWorkerContext, createData: ICreateData) {
+		this._ctx = ctx;
+		this._languageSettings = createData.options;
+		this._languageId = createData.languageId;
+
+		const data = createData.options.data;
+
+		const useDefaultDataProvider = data?.useDefaultDataProvider;
+		const customDataProviders: cssService.ICSSDataProvider[] = [];
+		if (data?.dataProviders) {
+			for (const id in data.dataProviders) {
+				customDataProviders.push(cssService.newCSSDataProvider(data.dataProviders[id]));
+			}
+		}
+		const lsOptions: cssService.LanguageServiceOptions = {
+			customDataProviders,
+			useDefaultDataProvider
+		};
+
+		switch (this._languageId) {
+			case 'css':
+				this._languageService = cssService.getCSSLanguageService(lsOptions);
+				break;
+			case 'less':
+				this._languageService = cssService.getLESSLanguageService(lsOptions);
+				break;
+			case 'scss':
+				this._languageService = cssService.getSCSSLanguageService(lsOptions);
+				break;
+			default:
+				throw new Error('Invalid language id: ' + this._languageId);
+		}
+		this._languageService.configure(this._languageSettings);
+	}
+
+	// --- language service host ---------------
+
+	async doValidation(uri: string): Promise<cssService.Diagnostic[]> {
+		let document = this._getTextDocument(uri);
+		if (document) {
+			let stylesheet = this._languageService.parseStylesheet(document);
+			let diagnostics = this._languageService.doValidation(document, stylesheet);
+			return Promise.resolve(diagnostics);
+		}
+		return Promise.resolve([]);
+	}
+	async doComplete(uri: string, position: cssService.Position): Promise<cssService.CompletionList> {
+		let document = this._getTextDocument(uri);
+		let stylesheet = this._languageService.parseStylesheet(document);
+		let completions = this._languageService.doComplete(document, position, stylesheet);
+		return Promise.resolve(completions);
+	}
+	async doHover(uri: string, position: cssService.Position): Promise<cssService.Hover> {
+		let document = this._getTextDocument(uri);
+		let stylesheet = this._languageService.parseStylesheet(document);
+		let hover = this._languageService.doHover(document, position, stylesheet);
+		return Promise.resolve(hover);
+	}
+	async findDefinition(uri: string, position: cssService.Position): Promise<cssService.Location> {
+		let document = this._getTextDocument(uri);
+		let stylesheet = this._languageService.parseStylesheet(document);
+		let definition = this._languageService.findDefinition(document, position, stylesheet);
+		return Promise.resolve(definition);
+	}
+	async findReferences(uri: string, position: cssService.Position): Promise<cssService.Location[]> {
+		let document = this._getTextDocument(uri);
+		let stylesheet = this._languageService.parseStylesheet(document);
+		let references = this._languageService.findReferences(document, position, stylesheet);
+		return Promise.resolve(references);
+	}
+	async findDocumentHighlights(
+		uri: string,
+		position: cssService.Position
+	): Promise<cssService.DocumentHighlight[]> {
+		let document = this._getTextDocument(uri);
+		let stylesheet = this._languageService.parseStylesheet(document);
+		let highlights = this._languageService.findDocumentHighlights(document, position, stylesheet);
+		return Promise.resolve(highlights);
+	}
+	async findDocumentSymbols(uri: string): Promise<cssService.SymbolInformation[]> {
+		let document = this._getTextDocument(uri);
+		let stylesheet = this._languageService.parseStylesheet(document);
+		let symbols = this._languageService.findDocumentSymbols(document, stylesheet);
+		return Promise.resolve(symbols);
+	}
+	async doCodeActions(
+		uri: string,
+		range: cssService.Range,
+		context: cssService.CodeActionContext
+	): Promise<cssService.Command[]> {
+		let document = this._getTextDocument(uri);
+		let stylesheet = this._languageService.parseStylesheet(document);
+		let actions = this._languageService.doCodeActions(document, range, context, stylesheet);
+		return Promise.resolve(actions);
+	}
+	async findDocumentColors(uri: string): Promise<cssService.ColorInformation[]> {
+		let document = this._getTextDocument(uri);
+		let stylesheet = this._languageService.parseStylesheet(document);
+		let colorSymbols = this._languageService.findDocumentColors(document, stylesheet);
+		return Promise.resolve(colorSymbols);
+	}
+	async getColorPresentations(
+		uri: string,
+		color: cssService.Color,
+		range: cssService.Range
+	): Promise<cssService.ColorPresentation[]> {
+		let document = this._getTextDocument(uri);
+		let stylesheet = this._languageService.parseStylesheet(document);
+		let colorPresentations = this._languageService.getColorPresentations(
+			document,
+			stylesheet,
+			color,
+			range
+		);
+		return Promise.resolve(colorPresentations);
+	}
+	async getFoldingRanges(
+		uri: string,
+		context?: { rangeLimit?: number }
+	): Promise<cssService.FoldingRange[]> {
+		let document = this._getTextDocument(uri);
+		let ranges = this._languageService.getFoldingRanges(document, context);
+		return Promise.resolve(ranges);
+	}
+	async getSelectionRanges(
+		uri: string,
+		positions: cssService.Position[]
+	): Promise<cssService.SelectionRange[]> {
+		let document = this._getTextDocument(uri);
+		let stylesheet = this._languageService.parseStylesheet(document);
+		let ranges = this._languageService.getSelectionRanges(document, positions, stylesheet);
+		return Promise.resolve(ranges);
+	}
+	async doRename(
+		uri: string,
+		position: cssService.Position,
+		newName: string
+	): Promise<cssService.WorkspaceEdit> {
+		let document = this._getTextDocument(uri);
+		let stylesheet = this._languageService.parseStylesheet(document);
+		let renames = this._languageService.doRename(document, position, newName, stylesheet);
+		return Promise.resolve(renames);
+	}
+	private _getTextDocument(uri: string): cssService.TextDocument {
+		let models = this._ctx.getMirrorModels();
+		for (let model of models) {
+			if (model.uri.toString() === uri) {
+				return cssService.TextDocument.create(
+					uri,
+					this._languageId,
+					model.version,
+					model.getValue()
+				);
+			}
+		}
+		return null;
+	}
+}
+
+export interface ICreateData {
+	languageId: string;
+	options: Options;
+}
+
+export function create(ctx: worker.IWorkerContext, createData: ICreateData): CSSWorker {
+	return new CSSWorker(ctx, createData);
+}

refactor/baselines/site-vendor/monaco-languages/monaco-css-src-fillers-vscode-nls.ts.txt

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export interface Options {
+	locale?: string;
+	cacheLanguageResolution?: boolean;
+}
+export interface LocalizeInfo {
+	key: string;
+	comment: string[];
+}
+export interface LocalizeFunc {
+	(info: LocalizeInfo, message: string, ...args: any[]): string;
+	(key: string, message: string, ...args: any[]): string;
+}
+export interface LoadFunc {
+	(file?: string): LocalizeFunc;
+}
+
+function format(message: string, args: any[]): string {
+	let result: string;
+
+	if (args.length === 0) {
+		result = message;
+	} else {
+		result = message.replace(/\{(\d+)\}/g, (match, rest) => {
+			let index = rest[0];
+			return typeof args[index] !== 'undefined' ? args[index] : match;
+		});
+	}
+	return result;
+}
+
+function localize(key: string | LocalizeInfo, message: string, ...args: any[]): string {
+	return format(message, args);
+}
+
+export function loadMessageBundle(file?: string): LocalizeFunc {
+	return localize;
+}
+
+export function config(opt?: Options | string): LoadFunc {
+	return loadMessageBundle;
+}

refactor/baselines/site-vendor/monaco-languages/monaco-css-src-tsconfig.json.txt

@@ -0,0 +1,10 @@
+{
+	"compilerOptions": {
+		"module": "amd",
+		"moduleResolution": "node",
+		"outDir": "../out/amd",
+		"declaration": true,
+		"target": "es5",
+		"lib": ["dom", "es5", "es2015.collection", "es2015.promise", "es2015.iterable"]
+	}
+}

refactor/baselines/site-vendor/monaco-languages/monaco-html-scripts-bundle.js.txt

@@ -0,0 +1,86 @@
+const requirejs = require('requirejs');
+const path = require('path');
+const fs = require('fs');
+const terser = require('terser');
+const helpers = require('monaco-plugin-helpers');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+
+const sha1 = helpers.getGitVersion(REPO_ROOT);
+const semver = require('../../package.json').version;
+const headerVersion = semver + '(' + sha1 + ')';
+
+const BUNDLED_FILE_HEADER = [
+	'/*!-----------------------------------------------------------------------------',
+	' * Copyright (c) Microsoft Corporation. All rights reserved.',
+	' * monaco-html version: ' + headerVersion,
+	' * Released under the MIT license',
+	' * https://github.com/Microsoft/monaco-html/blob/master/LICENSE.md',
+	' *-----------------------------------------------------------------------------*/',
+	''
+].join('\n');
+
+bundleOne('monaco.contribution');
+bundleOne('htmlMode', ['vs/language/html/monaco.contribution']);
+bundleOne('htmlWorker');
+
+function bundleOne(moduleId, exclude) {
+	requirejs.optimize(
+		{
+			baseUrl: 'out/amd/',
+			name: 'vs/language/html/' + moduleId,
+			out: 'release/dev/' + moduleId + '.js',
+			exclude: exclude,
+			paths: {
+				'vs/language/html': REPO_ROOT + '/monaco-html/out/amd',
+				'vs/language/html/fillers/monaco-editor-core':
+					REPO_ROOT + '/monaco-html/out/amd/fillers/monaco-editor-core-amd'
+			},
+			optimize: 'none',
+			packages: [
+				{
+					name: 'vscode-html-languageservice',
+					location: path.join(REPO_ROOT, 'node_modules/vscode-html-languageservice/lib/umd'),
+					main: 'htmlLanguageService'
+				},
+				{
+					name: 'vscode-languageserver-types',
+					location: path.join(REPO_ROOT, 'node_modules/vscode-languageserver-types/lib/umd'),
+					main: 'main'
+				},
+				{
+					name: 'vscode-languageserver-textdocument',
+					location: path.join(REPO_ROOT, 'node_modules/vscode-languageserver-textdocument/lib/umd'),
+					main: 'main'
+				},
+				{
+					name: 'vscode-uri',
+					location: path.join(REPO_ROOT, 'node_modules/vscode-uri/lib/umd'),
+					main: 'index'
+				},
+				{
+					name: 'vscode-nls',
+					location: path.join(REPO_ROOT, 'monaco-html/out/amd/fillers'),
+					main: 'vscode-nls'
+				}
+			]
+		},
+		async function (buildResponse) {
+			const devFilePath = path.join(REPO_ROOT, 'monaco-html/release/dev/' + moduleId + '.js');
+			const minFilePath = path.join(REPO_ROOT, 'monaco-html/release/min/' + moduleId + '.js');
+			const fileContents = fs.readFileSync(devFilePath).toString();
+			console.log();
+			console.log(`Minifying ${devFilePath}...`);
+			const result = await terser.minify(fileContents, {
+				output: {
+					comments: 'some'
+				}
+			});
+			console.log(`Done minifying ${devFilePath}.`);
+			try {
+				fs.mkdirSync(path.join(REPO_ROOT, 'monaco-html/release/min'));
+			} catch (err) {}
+			fs.writeFileSync(minFilePath, BUNDLED_FILE_HEADER + result.code);
+		}
+	);
+}

refactor/baselines/site-vendor/monaco-languages/monaco-html-src-fillers-vscode-nls.ts.txt

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export interface Options {
+	locale?: string;
+	cacheLanguageResolution?: boolean;
+}
+export interface LocalizeInfo {
+	key: string;
+	comment: string[];
+}
+export interface LocalizeFunc {
+	(info: LocalizeInfo, message: string, ...args: any[]): string;
+	(key: string, message: string, ...args: any[]): string;
+}
+export interface LoadFunc {
+	(file?: string): LocalizeFunc;
+}
+
+function format(message: string, args: any[]): string {
+	let result: string;
+
+	if (args.length === 0) {
+		result = message;
+	} else {
+		result = message.replace(/\{(\d+)\}/g, (match, rest) => {
+			let index = rest[0];
+			return typeof args[index] !== 'undefined' ? args[index] : match;
+		});
+	}
+	return result;
+}
+
+function localize(key: string | LocalizeInfo, message: string, ...args: any[]): string {
+	return format(message, args);
+}
+
+export function loadMessageBundle(file?: string): LocalizeFunc {
+	return localize;
+}
+
+export function config(opt?: Options | string): LoadFunc {
+	return loadMessageBundle;
+}

refactor/baselines/site-vendor/monaco-languages/monaco-html-src-htmlWorker.ts.txt

@@ -0,0 +1,137 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { worker } from './fillers/monaco-editor-core';
+import * as htmlService from 'vscode-html-languageservice';
+import type { Options } from './monaco.contribution';
+import { IHTMLDataProvider } from 'vscode-html-languageservice';
+
+export class HTMLWorker {
+	private _ctx: worker.IWorkerContext;
+	private _languageService: htmlService.LanguageService;
+	private _languageSettings: Options;
+	private _languageId: string;
+
+	constructor(ctx: worker.IWorkerContext, createData: ICreateData) {
+		this._ctx = ctx;
+		this._languageSettings = createData.languageSettings;
+		this._languageId = createData.languageId;
+
+		const data = this._languageSettings.data;
+
+		const useDefaultDataProvider = data?.useDefaultDataProvider;
+		const customDataProviders: IHTMLDataProvider[] = [];
+		if (data?.dataProviders) {
+			for (const id in data.dataProviders) {
+				customDataProviders.push(htmlService.newHTMLDataProvider(id, data.dataProviders[id]));
+			}
+		}
+		this._languageService = htmlService.getLanguageService({
+			useDefaultDataProvider,
+			customDataProviders
+		});
+	}
+
+	async doComplete(
+		uri: string,
+		position: htmlService.Position
+	): Promise<htmlService.CompletionList> {
+		let document = this._getTextDocument(uri);
+		let htmlDocument = this._languageService.parseHTMLDocument(document);
+		return Promise.resolve(
+			this._languageService.doComplete(
+				document,
+				position,
+				htmlDocument,
+				this._languageSettings && this._languageSettings.suggest
+			)
+		);
+	}
+	async format(
+		uri: string,
+		range: htmlService.Range,
+		options: htmlService.FormattingOptions
+	): Promise<htmlService.TextEdit[]> {
+		let document = this._getTextDocument(uri);
+		let formattingOptions = { ...this._languageSettings.format, ...options };
+		let textEdits = this._languageService.format(document, range, formattingOptions);
+		return Promise.resolve(textEdits);
+	}
+	async doHover(uri: string, position: htmlService.Position): Promise<htmlService.Hover> {
+		let document = this._getTextDocument(uri);
+		let htmlDocument = this._languageService.parseHTMLDocument(document);
+		let hover = this._languageService.doHover(document, position, htmlDocument);
+		return Promise.resolve(hover);
+	}
+	async findDocumentHighlights(
+		uri: string,
+		position: htmlService.Position
+	): Promise<htmlService.DocumentHighlight[]> {
+		let document = this._getTextDocument(uri);
+		let htmlDocument = this._languageService.parseHTMLDocument(document);
+		let highlights = this._languageService.findDocumentHighlights(document, position, htmlDocument);
+		return Promise.resolve(highlights);
+	}
+	async findDocumentLinks(uri: string): Promise<htmlService.DocumentLink[]> {
+		let document = this._getTextDocument(uri);
+		let links = this._languageService.findDocumentLinks(document, null);
+		return Promise.resolve(links);
+	}
+	async findDocumentSymbols(uri: string): Promise<htmlService.SymbolInformation[]> {
+		let document = this._getTextDocument(uri);
+		let htmlDocument = this._languageService.parseHTMLDocument(document);
+		let symbols = this._languageService.findDocumentSymbols(document, htmlDocument);
+		return Promise.resolve(symbols);
+	}
+	async getFoldingRanges(
+		uri: string,
+		context?: { rangeLimit?: number }
+	): Promise<htmlService.FoldingRange[]> {
+		let document = this._getTextDocument(uri);
+		let ranges = this._languageService.getFoldingRanges(document, context);
+		return Promise.resolve(ranges);
+	}
+	async getSelectionRanges(
+		uri: string,
+		positions: htmlService.Position[]
+	): Promise<htmlService.SelectionRange[]> {
+		let document = this._getTextDocument(uri);
+		let ranges = this._languageService.getSelectionRanges(document, positions);
+		return Promise.resolve(ranges);
+	}
+	async doRename(
+		uri: string,
+		position: htmlService.Position,
+		newName: string
+	): Promise<htmlService.WorkspaceEdit> {
+		let document = this._getTextDocument(uri);
+		let htmlDocument = this._languageService.parseHTMLDocument(document);
+		let renames = this._languageService.doRename(document, position, newName, htmlDocument);
+		return Promise.resolve(renames);
+	}
+	private _getTextDocument(uri: string): htmlService.TextDocument {
+		let models = this._ctx.getMirrorModels();
+		for (let model of models) {
+			if (model.uri.toString() === uri) {
+				return htmlService.TextDocument.create(
+					uri,
+					this._languageId,
+					model.version,
+					model.getValue()
+				);
+			}
+		}
+		return null;
+	}
+}
+
+export interface ICreateData {
+	languageId: string;
+	languageSettings: Options;
+}
+
+export function create(ctx: worker.IWorkerContext, createData: ICreateData): HTMLWorker {
+	return new HTMLWorker(ctx, createData);
+}

refactor/baselines/site-vendor/monaco-languages/monaco-html-src-tsconfig.json.txt

@@ -0,0 +1,10 @@
+{
+	"compilerOptions": {
+		"module": "amd",
+		"moduleResolution": "node",
+		"outDir": "../out/amd",
+		"declaration": true,
+		"target": "es5",
+		"lib": ["dom", "es5", "es2015.collection", "es2015.promise", "es2015.iterable"]
+	}
+}

refactor/baselines/site-vendor/monaco-languages/monaco-json-scripts-bundle.js.txt

@@ -0,0 +1,90 @@
+const requirejs = require('requirejs');
+const path = require('path');
+const fs = require('fs');
+const Terser = require('terser');
+const helpers = require('monaco-plugin-helpers');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+
+const sha1 = helpers.getGitVersion(REPO_ROOT);
+const semver = require('../../package.json').version;
+const headerVersion = semver + '(' + sha1 + ')';
+
+const BUNDLED_FILE_HEADER = [
+	'/*!-----------------------------------------------------------------------------',
+	' * Copyright (c) Microsoft Corporation. All rights reserved.',
+	' * monaco-json version: ' + headerVersion,
+	' * Released under the MIT license',
+	' * https://github.com/Microsoft/monaco-json/blob/master/LICENSE.md',
+	' *-----------------------------------------------------------------------------*/',
+	''
+].join('\n');
+
+bundleOne('monaco.contribution');
+bundleOne('jsonMode', ['vs/language/json/monaco.contribution']);
+bundleOne('jsonWorker');
+
+function bundleOne(moduleId, exclude) {
+	requirejs.optimize(
+		{
+			baseUrl: 'out/amd/',
+			name: 'vs/language/json/' + moduleId,
+			out: 'release/dev/' + moduleId + '.js',
+			exclude: exclude,
+			paths: {
+				'vs/language/json': REPO_ROOT + '/monaco-json/out/amd',
+				'vs/language/json/fillers/monaco-editor-core':
+					REPO_ROOT + '/monaco-json/out/amd/fillers/monaco-editor-core-amd'
+			},
+			optimize: 'none',
+			packages: [
+				{
+					name: 'vscode-json-languageservice',
+					location: path.join(REPO_ROOT, 'node_modules/vscode-json-languageservice/lib/umd'),
+					main: 'jsonLanguageService'
+				},
+				{
+					name: 'vscode-languageserver-types',
+					location: path.join(REPO_ROOT, 'node_modules/vscode-languageserver-types/lib/umd'),
+					main: 'main'
+				},
+				{
+					name: 'vscode-languageserver-textdocument',
+					location: path.join(REPO_ROOT, 'node_modules/vscode-languageserver-textdocument/lib/umd'),
+					main: 'main'
+				},
+				{
+					name: 'jsonc-parser',
+					location: path.join(REPO_ROOT, 'node_modules/jsonc-parser/lib/umd'),
+					main: 'main'
+				},
+				{
+					name: 'vscode-uri',
+					location: path.join(REPO_ROOT, 'node_modules/vscode-uri/lib/umd'),
+					main: 'index'
+				},
+				{
+					name: 'vscode-nls',
+					location: path.join(REPO_ROOT, 'monaco-json/out/amd/fillers'),
+					main: 'vscode-nls'
+				}
+			]
+		},
+		async function (buildResponse) {
+			const devFilePath = path.join(REPO_ROOT, 'monaco-json/release/dev/' + moduleId + '.js');
+			const minFilePath = path.join(REPO_ROOT, 'monaco-json/release/min/' + moduleId + '.js');
+			const fileContents = fs.readFileSync(devFilePath).toString();
+			console.log(`Minifying ${devFilePath}...`);
+			const result = await Terser.minify(fileContents, {
+				output: {
+					comments: 'some'
+				}
+			});
+			console.log(`Done minifying ${devFilePath}.`);
+			try {
+				fs.mkdirSync(path.join(REPO_ROOT, 'monaco-json/release/min'));
+			} catch (err) {}
+			fs.writeFileSync(minFilePath, BUNDLED_FILE_HEADER + result.code);
+		}
+	);
+}

refactor/baselines/site-vendor/monaco-languages/monaco-json-src-fillers-vscode-nls.ts.txt

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export interface Options {
+	locale?: string;
+	cacheLanguageResolution?: boolean;
+}
+export interface LocalizeInfo {
+	key: string;
+	comment: string[];
+}
+export interface LocalizeFunc {
+	(info: LocalizeInfo, message: string, ...args: any[]): string;
+	(key: string, message: string, ...args: any[]): string;
+}
+export interface LoadFunc {
+	(file?: string): LocalizeFunc;
+}
+
+function format(message: string, args: any[]): string {
+	let result: string;
+
+	if (args.length === 0) {
+		result = message;
+	} else {
+		result = message.replace(/\{(\d+)\}/g, (match, rest) => {
+			let index = rest[0];
+			return typeof args[index] !== 'undefined' ? args[index] : match;
+		});
+	}
+	return result;
+}
+
+function localize(key: string | LocalizeInfo, message: string, ...args: any[]): string {
+	return format(message, args);
+}
+
+export function loadMessageBundle(file?: string): LocalizeFunc {
+	return localize;
+}
+
+export function config(opt?: Options | string): LoadFunc {
+	return loadMessageBundle;
+}

refactor/baselines/site-vendor/monaco-languages/monaco-json-src-jsonWorker.ts.txt

@@ -0,0 +1,192 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as jsonService from 'vscode-json-languageservice';
+import type { worker } from './fillers/monaco-editor-core';
+import { URI } from 'vscode-uri';
+import { DiagnosticsOptions } from './monaco.contribution';
+
+let defaultSchemaRequestService;
+if (typeof fetch !== 'undefined') {
+	defaultSchemaRequestService = function (url) {
+		return fetch(url).then((response) => response.text());
+	};
+}
+
+export class JSONWorker {
+	private _ctx: worker.IWorkerContext;
+	private _languageService: jsonService.LanguageService;
+	private _languageSettings: DiagnosticsOptions;
+	private _languageId: string;
+
+	constructor(ctx: worker.IWorkerContext, createData: ICreateData) {
+		this._ctx = ctx;
+		this._languageSettings = createData.languageSettings;
+		this._languageId = createData.languageId;
+		this._languageService = jsonService.getLanguageService({
+			workspaceContext: {
+				resolveRelativePath: (relativePath: string, resource: string) => {
+					const base = resource.substr(0, resource.lastIndexOf('/') + 1);
+					return resolvePath(base, relativePath);
+				}
+			},
+			schemaRequestService: createData.enableSchemaRequest && defaultSchemaRequestService
+		});
+		this._languageService.configure(this._languageSettings);
+	}
+
+	async doValidation(uri: string): Promise<jsonService.Diagnostic[]> {
+		let document = this._getTextDocument(uri);
+		if (document) {
+			let jsonDocument = this._languageService.parseJSONDocument(document);
+			return this._languageService.doValidation(document, jsonDocument, this._languageSettings);
+		}
+		return Promise.resolve([]);
+	}
+	async doComplete(
+		uri: string,
+		position: jsonService.Position
+	): Promise<jsonService.CompletionList> {
+		let document = this._getTextDocument(uri);
+		let jsonDocument = this._languageService.parseJSONDocument(document);
+		return this._languageService.doComplete(document, position, jsonDocument);
+	}
+	async doResolve(item: jsonService.CompletionItem): Promise<jsonService.CompletionItem> {
+		return this._languageService.doResolve(item);
+	}
+	async doHover(uri: string, position: jsonService.Position): Promise<jsonService.Hover> {
+		let document = this._getTextDocument(uri);
+		let jsonDocument = this._languageService.parseJSONDocument(document);
+		return this._languageService.doHover(document, position, jsonDocument);
+	}
+	async format(
+		uri: string,
+		range: jsonService.Range,
+		options: jsonService.FormattingOptions
+	): Promise<jsonService.TextEdit[]> {
+		let document = this._getTextDocument(uri);
+		let textEdits = this._languageService.format(document, range, options);
+		return Promise.resolve(textEdits);
+	}
+	async resetSchema(uri: string): Promise<boolean> {
+		return Promise.resolve(this._languageService.resetSchema(uri));
+	}
+	async findDocumentSymbols(uri: string): Promise<jsonService.SymbolInformation[]> {
+		let document = this._getTextDocument(uri);
+		let jsonDocument = this._languageService.parseJSONDocument(document);
+		let symbols = this._languageService.findDocumentSymbols(document, jsonDocument);
+		return Promise.resolve(symbols);
+	}
+	async findDocumentColors(uri: string): Promise<jsonService.ColorInformation[]> {
+		let document = this._getTextDocument(uri);
+		let jsonDocument = this._languageService.parseJSONDocument(document);
+		let colorSymbols = this._languageService.findDocumentColors(document, jsonDocument);
+		return Promise.resolve(colorSymbols);
+	}
+	async getColorPresentations(
+		uri: string,
+		color: jsonService.Color,
+		range: jsonService.Range
+	): Promise<jsonService.ColorPresentation[]> {
+		let document = this._getTextDocument(uri);
+		let jsonDocument = this._languageService.parseJSONDocument(document);
+		let colorPresentations = this._languageService.getColorPresentations(
+			document,
+			jsonDocument,
+			color,
+			range
+		);
+		return Promise.resolve(colorPresentations);
+	}
+	async getFoldingRanges(
+		uri: string,
+		context?: { rangeLimit?: number }
+	): Promise<jsonService.FoldingRange[]> {
+		let document = this._getTextDocument(uri);
+		let ranges = this._languageService.getFoldingRanges(document, context);
+		return Promise.resolve(ranges);
+	}
+	async getSelectionRanges(
+		uri: string,
+		positions: jsonService.Position[]
+	): Promise<jsonService.SelectionRange[]> {
+		let document = this._getTextDocument(uri);
+		let jsonDocument = this._languageService.parseJSONDocument(document);
+		let ranges = this._languageService.getSelectionRanges(document, positions, jsonDocument);
+		return Promise.resolve(ranges);
+	}
+	private _getTextDocument(uri: string): jsonService.TextDocument {
+		let models = this._ctx.getMirrorModels();
+		for (let model of models) {
+			if (model.uri.toString() === uri) {
+				return jsonService.TextDocument.create(
+					uri,
+					this._languageId,
+					model.version,
+					model.getValue()
+				);
+			}
+		}
+		return null;
+	}
+}
+
+// URI path utilities, will (hopefully) move to vscode-uri
+
+const Slash = '/'.charCodeAt(0);
+const Dot = '.'.charCodeAt(0);
+
+function isAbsolutePath(path: string) {
+	return path.charCodeAt(0) === Slash;
+}
+
+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);
+}
+
+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;
+}
+
+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();
+}
+
+export interface ICreateData {
+	languageId: string;
+	languageSettings: DiagnosticsOptions;
+	enableSchemaRequest: boolean;
+}
+
+export function create(ctx: worker.IWorkerContext, createData: ICreateData): JSONWorker {
+	return new JSONWorker(ctx, createData);
+}

refactor/baselines/site-vendor/monaco-languages/monaco-json-src-tsconfig.json.txt

@@ -0,0 +1,10 @@
+{
+	"compilerOptions": {
+		"module": "amd",
+		"moduleResolution": "node",
+		"outDir": "../out/amd",
+		"declaration": true,
+		"target": "es5",
+		"lib": ["dom", "es5", "es2015.collection", "es2015.promise", "es2015.iterable"]
+	}
+}