<|start_filename|>extensions/theme-monokai-dimmed/package.nls.json<|end_filename|>
{
	"displayName": "Monokai Dimmed Theme",
	"description": "Monokai dimmed theme for Visual Studio Code"
}

<|start_filename|>extensions/theme-seti/package.nls.json<|end_filename|>
{
	"displayName": "Seti File Icon Theme",
	"description": "A file icon theme made out of the Seti UI file icons"
}

<|start_filename|>src/bootstrap-node.js<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

//@ts-check
'use strict';

/**
 * Add support for redirecting the loading of node modules
 *
 * @param {string} injectPath
 */
exports.injectNodeModuleLookupPath = function (injectPath) {
	if (!injectPath) {
		throw new Error('Missing injectPath');
	}

	const Module = require('module');
	const path = require('path');

	const nodeModulesPath = path.join(__dirname, '../node_modules');

	// @ts-ignore
	const originalResolveLookupPaths = Module._resolveLookupPaths;

	// @ts-ignore
	Module._resolveLookupPaths = function (moduleName, parent) {
		const paths = originalResolveLookupPaths(moduleName, parent);
		if (Array.isArray(paths)) {
			for (let i = 0, len = paths.length; i < len; i++) {
				if (paths[i] === nodeModulesPath) {
					paths.splice(i, 0, injectPath);
					break;
				}
			}
		}

		return paths;
	};
};

exports.removeGlobalNodeModuleLookupPaths = function () {
	const Module = require('module');
	// @ts-ignore
	const globalPaths = Module.globalPaths;

	// @ts-ignore
	const originalResolveLookupPaths = Module._resolveLookupPaths;

	// @ts-ignore
	Module._resolveLookupPaths = function (moduleName, parent) {
		const paths = originalResolveLookupPaths(moduleName, parent);
		let commonSuffixLength = 0;
		while (commonSuffixLength < paths.length && paths[paths.length - 1 - commonSuffixLength] === globalPaths[globalPaths.length - 1 - commonSuffixLength]) {
			commonSuffixLength++;
		}
		return paths.slice(0, paths.length - commonSuffixLength);
	};
};


<|start_filename|>extensions/ini/package.nls.json<|end_filename|>
{
	"displayName": "Ini Language Basics",
	"description": "Provides syntax highlighting and bracket matching in Ini files."
}

<|start_filename|>src/vs/base/common/insane/insane.js<|end_filename|>
/*
The MIT License (MIT)

Copyright © 2015 <NAME>

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

let __insane_func;

(function () { function r(e, n, t) { function o(i, f) { if (!n[i]) { if (!e[i]) { var c = "function" == typeof require && require; if (!f && c) return c(i, !0); if (u) return u(i, !0); var a = new Error("Cannot find module '" + i + "'"); throw a.code = "MODULE_NOT_FOUND", a } var p = n[i] = { exports: {} }; e[i][0].call(p.exports, function (r) { var n = e[i][1][r]; return o(n || r) }, p, p.exports, r, e, n, t) } return n[i].exports } for (var u = "function" == typeof require && require, i = 0; i < t.length; i++)o(t[i]); return o } return r })()({
	1: [function (require, module, exports) {
		'use strict';

		var toMap = require('./toMap');
		var uris = ['background', 'base', 'cite', 'href', 'longdesc', 'src', 'usemap'];

		module.exports = {
			uris: toMap(uris) // attributes that have an href and hence need to be sanitized
		};

	}, { "./toMap": 10 }], 2: [function (require, module, exports) {
		'use strict';

		var defaults = {
			allowedAttributes: {
				'*': ['title', 'accesskey'],
				a: ['href', 'name', 'target', 'aria-label'],
				iframe: ['allowfullscreen', 'frameborder', 'src'],
				img: ['src', 'alt', 'title', 'aria-label']
			},
			allowedClasses: {},
			allowedSchemes: ['http', 'https', 'mailto'],
			allowedTags: [
				'a', 'abbr', 'article', 'b', 'blockquote', 'br', 'caption', 'code', 'del', 'details', 'div', 'em',
				'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'i', 'img', 'ins', 'kbd', 'li', 'main', 'mark',
				'ol', 'p', 'pre', 'section', 'span', 'strike', 'strong', 'sub', 'summary', 'sup', 'table',
				'tbody', 'td', 'th', 'thead', 'tr', 'u', 'ul'
			],
			filter: null
		};

		module.exports = defaults;

	}, {}], 3: [function (require, module, exports) {
		'use strict';

		var toMap = require('./toMap');
		var voids = ['area', 'br', 'col', 'hr', 'img', 'wbr', 'input', 'base', 'basefont', 'link', 'meta'];

		module.exports = {
			voids: toMap(voids)
		};

	}, { "./toMap": 10 }], 4: [function (require, module, exports) {
		'use strict';

		var he = require('he');
		var assign = require('assignment');
		var parser = require('./parser');
		var sanitizer = require('./sanitizer');
		var defaults = require('./defaults');

		function insane(html, options, strict) {
			var buffer = [];
			var configuration = strict === true ? options : assign({}, defaults, options);
			var handler = sanitizer(buffer, configuration);

			parser(html, handler);

			return buffer.join('');
		}

		insane.defaults = defaults;
		module.exports = insane;
		__insane_func = insane;

	}, { "./defaults": 2, "./parser": 7, "./sanitizer": 8, "assignment": 6, "he": 9 }], 5: [function (require, module, exports) {
		'use strict';

		module.exports = function lowercase(string) {
			return typeof string === 'string' ? string.toLowerCase() : string;
		};

	}, {}], 6: [function (require, module, exports) {
		'use strict';

		function assignment(result) {
			var stack = Array.prototype.slice.call(arguments, 1);
			var item;
			var key;
			while (stack.length) {
				item = stack.shift();
				for (key in item) {
					if (item.hasOwnProperty(key)) {
						if (Object.prototype.toString.call(result[key]) === '[object Object]') {
							result[key] = assignment(result[key], item[key]);
						} else {
							result[key] = item[key];
						}
					}
				}
			}
			return result;
		}

		module.exports = assignment;

	}, {}], 7: [function (require, module, exports) {
		'use strict';

		var he = require('he');
		var lowercase = require('./lowercase');
		var attributes = require('./attributes');
		var elements = require('./elements');
		var rstart = /^<\s*([\w:-]+)((?:\s+[\w:-]+(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)\s*>/;
		var rend = /^<\s*\/\s*([\w:-]+)[^>]*>/;
		var rattrs = /([\w:-]+)(?:\s*=\s*(?:(?:"((?:[^"])*)")|(?:'((?:[^'])*)')|([^>\s]+)))?/g;
		var rtag = /^</;
		var rtagend = /^<\s*\//;

		function createStack() {
			var stack = [];
			stack.lastItem = function lastItem() {
				return stack[stack.length - 1];
			};
			return stack;
		}

		function parser(html, handler) {
			var stack = createStack();
			var last = html;
			var chars;

			while (html) {
				parsePart();
			}
			parseEndTag(); // clean up any remaining tags

			function parsePart() {
				chars = true;
				parseTag();

				var same = html === last;
				last = html;

				if (same) { // discard, because it's invalid
					html = '';
				}
			}

			function parseTag() {
				if (html.substr(0, 4) === '<!--') { // comments
					parseComment();
				} else if (rtagend.test(html)) {
					parseEdge(rend, parseEndTag);
				} else if (rtag.test(html)) {
					parseEdge(rstart, parseStartTag);
				}
				parseTagDecode();
			}

			function parseEdge(regex, parser) {
				var match = html.match(regex);
				if (match) {
					html = html.substring(match[0].length);
					match[0].replace(regex, parser);
					chars = false;
				}
			}

			function parseComment() {
				var index = html.indexOf('-->');
				if (index >= 0) {
					if (handler.comment) {
						handler.comment(html.substring(4, index));
					}
					html = html.substring(index + 3);
					chars = false;
				}
			}

			function parseTagDecode() {
				if (!chars) {
					return;
				}
				var text;
				var index = html.indexOf('<');
				if (index >= 0) {
					text = html.substring(0, index);
					html = html.substring(index);
				} else {
					text = html;
					html = '';
				}
				if (handler.chars) {
					handler.chars(text);
				}
			}

			function parseStartTag(tag, tagName, rest, unary) {
				var attrs = {};
				var low = lowercase(tagName);
				var u = elements.voids[low] || !!unary;

				rest.replace(rattrs, attrReplacer);

				if (!u) {
					stack.push(low);
				}
				if (handler.start) {
					handler.start(low, attrs, u);
				}

				function attrReplacer(match, name, doubleQuotedValue, singleQuotedValue, unquotedValue) {
					if (doubleQuotedValue === void 0 && singleQuotedValue === void 0 && unquotedValue === void 0) {
						attrs[name] = void 0; // attribute is like <button disabled></button>
					} else {
						attrs[name] = he.decode(doubleQuotedValue || singleQuotedValue || unquotedValue || '');
					}
				}
			}

			function parseEndTag(tag, tagName) {
				var i;
				var pos = 0;
				var low = lowercase(tagName);
				if (low) {
					for (pos = stack.length - 1; pos >= 0; pos--) {
						if (stack[pos] === low) {
							break; // find the closest opened tag of the same type
						}
					}
				}
				if (pos >= 0) {
					for (i = stack.length - 1; i >= pos; i--) {
						if (handler.end) { // close all the open elements, up the stack
							handler.end(stack[i]);
						}
					}
					stack.length = pos;
				}
			}
		}

		module.exports = parser;

	}, { "./attributes": 1, "./elements": 3, "./lowercase": 5, "he": 9 }], 8: [function (require, module, exports) {
		'use strict';

		var he = require('he');
		var lowercase = require('./lowercase');
		var attributes = require('./attributes');
		var elements = require('./elements');

		function sanitizer(buffer, options) {
			var last;
			var context;
			var o = options || {};

			reset();

			return {
				start: start,
				end: end,
				chars: chars
			};

			function out(value) {
				buffer.push(value);
			}

			function start(tag, attrs, unary) {
				var low = lowercase(tag);

				if (context.ignoring) {
					ignore(low); return;
				}
				if ((o.allowedTags || []).indexOf(low) === -1) {
					ignore(low); return;
				}
				if (o.filter && !o.filter({ tag: low, attrs: attrs })) {
					ignore(low); return;
				}

				out('<');
				out(low);
				Object.keys(attrs).forEach(parse);
				out(unary ? '/>' : '>');

				function parse(key) {
					var value = attrs[key];
					var classesOk = (o.allowedClasses || {})[low] || [];
					var attrsOk = (o.allowedAttributes || {})[low] || [];
					attrsOk = attrsOk.concat((o.allowedAttributes || {})['*'] || []);
					var valid;
					var lkey = lowercase(key);
					if (lkey === 'class' && attrsOk.indexOf(lkey) === -1) {
						value = value.split(' ').filter(isValidClass).join(' ').trim();
						valid = value.length;
					} else {
						valid = attrsOk.indexOf(lkey) !== -1 && (attributes.uris[lkey] !== true || testUrl(value));
					}
					if (valid) {
						out(' ');
						out(key);
						if (typeof value === 'string') {
							out('="');
							out(he.encode(value));
							out('"');
						}
					}
					function isValidClass(className) {
						return classesOk && classesOk.indexOf(className) !== -1;
					}
				}
			}

			function end(tag) {
				var low = lowercase(tag);
				var allowed = (o.allowedTags || []).indexOf(low) !== -1;
				if (allowed) {
					if (context.ignoring === false) {
						out('</');
						out(low);
						out('>');
					} else {
						unignore(low);
					}
				} else {
					unignore(low);
				}
			}

			function testUrl(text) {
				var start = text[0];
				if (start === '#' || start === '/') {
					return true;
				}
				var colon = text.indexOf(':');
				if (colon === -1) {
					return true;
				}
				var questionmark = text.indexOf('?');
				if (questionmark !== -1 && colon > questionmark) {
					return true;
				}
				var hash = text.indexOf('#');
				if (hash !== -1 && colon > hash) {
					return true;
				}
				return o.allowedSchemes.some(matches);

				function matches(scheme) {
					return text.indexOf(scheme + ':') === 0;
				}
			}

			function chars(text) {
				if (context.ignoring === false) {
					out(o.transformText ? o.transformText(text) : text);
				}
			}

			function ignore(tag) {
				if (elements.voids[tag]) {
					return;
				}
				if (context.ignoring === false) {
					context = { ignoring: tag, depth: 1 };
				} else if (context.ignoring === tag) {
					context.depth++;
				}
			}

			function unignore(tag) {
				if (context.ignoring === tag) {
					if (--context.depth <= 0) {
						reset();
					}
				}
			}

			function reset() {
				context = { ignoring: false, depth: 0 };
			}
		}

		module.exports = sanitizer;

	}, { "./attributes": 1, "./elements": 3, "./lowercase": 5, "he": 9 }], 9: [function (require, module, exports) {
		'use strict';

		var escapes = {
			'&': '&amp;',
			'<': '&lt;',
			'>': '&gt;',
			'"': '&quot;',
			"'": '&#39;'
		};
		var unescapes = {
			'&amp;': '&',
			'&lt;': '<',
			'&gt;': '>',
			'&quot;': '"',
			'&#39;': "'"
		};
		var rescaped = /(&amp;|&lt;|&gt;|&quot;|&#39;)/g;
		var runescaped = /[&<>"']/g;

		function escapeHtmlChar(match) {
			return escapes[match];
		}
		function unescapeHtmlChar(match) {
			return unescapes[match];
		}

		function escapeHtml(text) {
			return text == null ? '' : String(text).replace(runescaped, escapeHtmlChar);
		}

		function unescapeHtml(html) {
			return html == null ? '' : String(html).replace(rescaped, unescapeHtmlChar);
		}

		escapeHtml.options = unescapeHtml.options = {};

		module.exports = {
			encode: escapeHtml,
			escape: escapeHtml,
			decode: unescapeHtml,
			unescape: unescapeHtml,
			version: '1.0.0-browser'
		};

	}, {}], 10: [function (require, module, exports) {
		'use strict';

		function toMap(list) {
			return list.reduce(asKey, {});
		}

		function asKey(accumulator, item) {
			accumulator[item] = true;
			return accumulator;
		}

		module.exports = toMap;

	}, {}]
}, {}, [4]);

// ESM-comment-begin
define(function() { return { insane: __insane_func }; });
// ESM-comment-end

// ESM-uncomment-begin
// export var insane = __insane_func;
// ESM-uncomment-end


<|start_filename|>src/vs/workbench/services/hover/browser/media/hover.css<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

.monaco-workbench .workbench-hover {
	position: relative;
	font-size: 14px;
	line-height: 19px;
	animation: fadein 100ms linear;
	/* Must be higher than sash's z-index and terminal canvases */
	z-index: 40;
	overflow: hidden;
	max-width: 700px;
}

.monaco-workbench .workbench-hover a {
	color: #3794ff;
}

.monaco-workbench .workbench-hover.right-aligned {
	/* The context view service wraps strangely when it's right up against the edge without this */
	left: 1px;
}

.monaco-workbench .workbench-hover.right-aligned .hover-row.status-bar .actions {
	flex-direction: row-reverse;
}

.monaco-workbench .workbench-hover.right-aligned .hover-row.status-bar .actions .action-container {
	margin-right: 0;
	margin-left: 16px;
}


<|start_filename|>extensions/gulp/package.nls.json<|end_filename|>
{
	"description": "Extension to add Gulp capabilities to VSCode.",
	"displayName": "Gulp support for VSCode",
	"config.gulp.autoDetect": "Controls whether auto detection of Gulp tasks is on or off. Default is on.",
	"gulp.taskDefinition.type.description": "The Gulp task to customize.",
	"gulp.taskDefinition.file.description": "The Gulp file that provides the task. Can be omitted."
}

<|start_filename|>build/gulpfile.vscode.web.js<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

'use strict';

const gulp = require('gulp');

const noop = () => { return Promise.resolve(); };

gulp.task('minify-vscode-web', noop);
gulp.task('vscode-web', noop);
gulp.task('vscode-web-min', noop);
gulp.task('vscode-web-ci', noop);
gulp.task('vscode-web-min-ci', noop);


<|start_filename|>extensions/theme-solarized-light/package.nls.json<|end_filename|>
{
	"displayName": "Solarized Light Theme",
	"description": "Solarized light theme for Visual Studio Code"
}

<|start_filename|>src/vs/base/browser/ui/codicons/codicon/codicon-modifications.css<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

.codicon-wrench-subaction {
	opacity: 0.5;
}


<|start_filename|>src/vs/editor/standalone/browser/quickInput/standaloneQuickInput.css<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

.quick-input-widget {
	font-size: 13px;
}

.quick-input-widget .monaco-highlighted-label .highlight,
.quick-input-widget .monaco-highlighted-label .highlight {
	color: #0066BF;
}

.vs-dark .quick-input-widget .monaco-highlighted-label .highlight,
.vs-dark .quick-input-widget .monaco-highlighted-label .highlight {
	color: #0097fb;
}

.hc-black .quick-input-widget .monaco-highlighted-label .highlight,
.hc-black .quick-input-widget .monaco-highlighted-label .highlight {
	color: #F38518;
}


<|start_filename|>extensions/shellscript/package.nls.json<|end_filename|>
{
	"displayName": "Shell Script Language Basics",
	"description": "Provides syntax highlighting and bracket matching in Shell Script files."
}

<|start_filename|>extensions/perl/package.nls.json<|end_filename|>
{
	"displayName": "Perl Language Basics",
	"description": "Provides syntax highlighting and bracket matching in Perl files."
}

<|start_filename|>extensions/handlebars/package.nls.json<|end_filename|>
{
	"displayName": "Handlebars Language Basics",
	"description": "Provides syntax highlighting and bracket matching in Handlebars files."
}

<|start_filename|>src/vs/workbench/contrib/remote/browser/media/tunnelView.css<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

.customview-tree .tunnel-view-label {
	flex: 1;
}


<|start_filename|>src/vs/base/browser/ui/codicons/codicon/codicon-animations.css<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

@keyframes codicon-spin {
	100% {
		transform:rotate(360deg);
	}
}

.codicon-animation-spin {
	/* Use steps to throttle FPS to reduce CPU usage */
	animation: codicon-spin 1.5s steps(30) infinite;
}


<|start_filename|>extensions/swift/package.nls.json<|end_filename|>
{
	"displayName": "Swift Language Basics",
	"description": "Provides snippets, syntax highlighting and bracket matching in Swift files."
}

<|start_filename|>src/vs/workbench/browser/actions/media/actions.css<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

.monaco-workbench .quick-input-list .quick-input-list-entry.has-actions:hover .quick-input-list-entry-action-bar .action-label.dirty-workspace::before {
	content: "\ea76"; /* Close icon flips between black dot and "X" for dirty workspaces */
}

.monaco-workbench .screencast-mouse {
	position: absolute;
	border-width: 2px;
	border-style: solid;
	border-radius: 50%;
	z-index: 100000;
	content: ' ';
	pointer-events: none;
	display: none;
}

.monaco-workbench .screencast-keyboard {
	position: absolute;
	background-color: rgba(0, 0, 0 ,0.5);
	width: 100%;
	left: 0;
	z-index: 100000;
	pointer-events: none;
	color: #eee;
	line-height: 1.75em;
	text-align: center;
	transition: opacity 0.3s ease-out;
	white-space: nowrap;
	overflow: hidden;
	text-overflow: ellipsis;
}

.monaco-workbench .screencast-keyboard:empty {
	opacity: 0;
}

.monaco-workbench .screencast-keyboard > .key {
	padding: 0 8px;
	box-shadow: inset 0 -3px 0 hsla(0,0%,73%,.4);
	margin-right: 6px;
	border: 1px solid hsla(0,0%,80%,.4);
	border-radius: 5px;
	background-color: rgba(255, 255, 255, 0.05);
}


<|start_filename|>src/vs/editor/contrib/message/messageController.css<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

.monaco-editor .monaco-editor-overlaymessage {
	padding-bottom: 8px;
	z-index: 10000;
}

@keyframes fadeIn {
	from { opacity: 0; }
	to { opacity: 1; }
}
.monaco-editor .monaco-editor-overlaymessage.fadeIn {
	animation: fadeIn 150ms ease-out;
}

@keyframes fadeOut {
	from { opacity: 1; }
	to { opacity: 0; }
}
.monaco-editor .monaco-editor-overlaymessage.fadeOut {
	animation: fadeOut 100ms ease-out;
}

.monaco-editor .monaco-editor-overlaymessage .message {
	padding: 1px 4px;
}

.monaco-editor .monaco-editor-overlaymessage .anchor {
	width: 0 !important;
	height: 0 !important;
	border-color: transparent;
	border-style: solid;
	z-index: 1000;
	border-width: 8px;
	position: absolute;
}


<|start_filename|>extensions/perl/package.json<|end_filename|>
{
	"name": "perl",
	"displayName": "%displayName%",
	"description": "%description%",
	"version": "1.0.0",
	"publisher": "vscode",
	"license": "MIT",
	"engines": { "vscode": "*" },
	"scripts": {
		"update-grammar": "node ../../build/npm/update-grammar.js textmate/perl.tmbundle Syntaxes/Perl.plist ./syntaxes/perl.tmLanguage.json Syntaxes/Perl%206.tmLanguage ./syntaxes/perl6.tmLanguage.json"
	},
	"contributes": {
		"languages": [{
			"id": "perl",
			"aliases": ["Perl", "perl"],
			"extensions": [".pl", ".pm", ".pod", ".t", ".PL", ".psgi"],
			"firstLine": "^#!.*\\bperl\\b",
			"configuration": "./perl.language-configuration.json"
		}, {
			"id": "perl6",
			"aliases": ["Perl 6", "perl6"],
			"extensions": [".p6", ".pl6", ".pm6", ".nqp"],
			"firstLine": "(^#!.*\\bperl6\\b)|use\\s+v6",
			"configuration": "./perl6.language-configuration.json"
		}],
		"grammars": [{
			"language": "perl",
			"scopeName": "source.perl",
			"path": "./syntaxes/perl.tmLanguage.json"
		}, {
			"language": "perl6",
			"scopeName": "source.perl.6",
			"path": "./syntaxes/perl6.tmLanguage.json"
		}]
	}
}

<|start_filename|>extensions/php/build/update-grammar.js<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
'use strict';

const updateGrammar = require('../../../build/npm/update-grammar');

function adaptInjectionScope(grammar) {
	// we're using the HTML grammar from https://github.com/textmate/html.tmbundle which has moved away from source.js.embedded.html
	// also we need to add source.css scope for PHP code in <style> tags, which are handled differently in atom
	const oldInjectionKey = "text.html.php - (meta.embedded | meta.tag), L:((text.html.php meta.tag) - (meta.embedded.block.php | meta.embedded.line.php)), L:(source.js.embedded.html - (meta.embedded.block.php | meta.embedded.line.php))";
	const newInjectionKey = "text.html.php - (meta.embedded | meta.tag), L:((text.html.php meta.tag) - (meta.embedded.block.php | meta.embedded.line.php)), L:(source.js - (meta.embedded.block.php | meta.embedded.line.php)), L:(source.css - (meta.embedded.block.php | meta.embedded.line.php))";

	const injections = grammar.injections;
	const injection = injections[oldInjectionKey];
	if (!injection) {
		throw new Error("Can not find PHP injection to patch");
	}
	delete injections[oldInjectionKey];
	injections[newInjectionKey] = injection;
}

function includeDerivativeHtml(grammar) {
	grammar.patterns.forEach(pattern => {
		if (pattern.include === 'text.html.basic') {
			pattern.include = 'text.html.derivative';
		}
	});
}

// Workaround for https://github.com/microsoft/vscode/issues/40279
// and https://github.com/microsoft/vscode-textmate/issues/59
function fixBadRegex(grammar) {
	function fail(msg) {
		throw new Error(`fixBadRegex callback couldn't patch ${msg}. It may be obsolete`);
	}

	const scopeResolution = grammar.repository['scope-resolution'];
	if (scopeResolution) {
		const match = scopeResolution.patterns[0].match;
		if (match === '(?i)([a-z_\\x{7f}-\\x{7fffffff}\\\\][a-z0-9_\\x{7f}-\\x{7fffffff}\\\\]*)(?=\\s*::)') {
			scopeResolution.patterns[0].match = '([A-Za-z_\\x{7f}-\\x{7fffffff}\\\\][A-Za-z0-9_\\x{7f}-\\x{7fffffff}\\\\]*)(?=\\s*::)';
		} else {
			fail('scope-resolution.match');
		}
	} else {
		fail('scope-resolution');
	}

	const functionCall = grammar.repository['function-call'];
	if (functionCall) {
		const begin0 = functionCall.patterns[0].begin;
		if (begin0 === '(?xi)\n(\n  \\\\?(?<![a-z0-9_\\x{7f}-\\x{7fffffff}])                            # Optional root namespace\n  [a-z_\\x{7f}-\\x{7fffffff}][a-z0-9_\\x{7f}-\\x{7fffffff}]*          # First namespace\n  (?:\\\\[a-z_\\x{7f}-\\x{7fffffff}][a-z0-9_\\x{7f}-\\x{7fffffff}]*)+ # Additional namespaces\n)\\s*(\\()') {
			functionCall.patterns[0].begin = '(?x)\n(\n  \\\\?(?<![a-zA-Z0-9_\\x{7f}-\\x{7fffffff}])                            # Optional root namespace\n  [a-zA-Z_\\x{7f}-\\x{7fffffff}][a-zA-Z0-9_\\x{7f}-\\x{7fffffff}]*          # First namespace\n  (?:\\\\[a-zA-Z_\\x{7f}-\\x{7fffffff}][a-zA-Z0-9_\\x{7f}-\\x{7fffffff}]*)+ # Additional namespaces\n)\\s*(\\()';
		} else {
			fail('function-call.begin0');
		}

		const begin1 = functionCall.patterns[1].begin;
		if (begin1 === '(?i)(\\\\)?(?<![a-z0-9_\\x{7f}-\\x{7fffffff}])([a-z_\\x{7f}-\\x{7fffffff}][a-z0-9_\\x{7f}-\\x{7fffffff}]*)\\s*(\\()') {
			functionCall.patterns[1].begin = '(\\\\)?(?<![a-zA-Z0-9_\\x{7f}-\\x{7fffffff}])([a-zA-Z_\\x{7f}-\\x{7fffffff}][a-zA-Z0-9_\\x{7f}-\\x{7fffffff}]*)\\s*(\\()';
		} else {
			fail('function-call.begin1');
		}
	} else {
		fail('function-call');
	}
}

updateGrammar.update('atom/language-php', 'grammars/php.cson', './syntaxes/php.tmLanguage.json', fixBadRegex);
updateGrammar.update('atom/language-php', 'grammars/html.cson', './syntaxes/html.tmLanguage.json', grammar => {
	adaptInjectionScope(grammar);
	includeDerivativeHtml(grammar);
});


<|start_filename|>extensions/git/cgmanifest.json<|end_filename|>
{
	"registrations": [
		{
			"component": {
				"type": "git",
				"git": {
					"name": "textmate/git.tmbundle",
					"repositoryUrl": "https://github.com/textmate/git.tmbundle",
					"commitHash": "5870cf3f8abad3a6637bdf69250b5d2ded427dc4"
				}
			},
			"licenseDetail": [
				"Copyright (c) 2008 <NAME>",
				"",
				"Permission is hereby granted, free of charge, to any person obtaining",
				"a copy of this software and associated documentation files (the\"",
				"Software\"), to deal in the Software without restriction, including",
				"without limitation the rights to use, copy, modify, merge, publish,",
				"distribute, sublicense, and/or sell copies of the Software, and to",
				"permit persons to whom the Software is furnished to do so, subject to",
				"the following conditions:",
				"",
				"The above copyright notice and this permission notice shall be",
				"included in all copies or substantial portions of the Software.",
				"",
				"THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,",
				"EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF",
				"MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND",
				"NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE",
				"LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION",
				"OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION",
				"WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."
			],
			"license": "MIT",
			"version": "0.0.0"
		},
		{
			"component": {
				"type": "git",
				"git": {
					"name": "textmate/diff.tmbundle",
					"repositoryUrl": "https://github.com/textmate/diff.tmbundle",
					"commitHash": "0593bb775eab1824af97ef2172fd38822abd97d7"
				}
			},
			"licenseDetail": [
				"Copyright (c) textmate-diff.tmbundle project authors",
				"",
				"If not otherwise specified (see below), files in this repository fall under the following license:",
				"",
				"Permission to copy, use, modify, sell and distribute this",
				"software is granted. This software is provided \"as is\" without",
				"express or implied warranty, and with no claim as to its",
				"suitability for any purpose.",
				"",
				"An exception is made for files in readable text which contain their own license information,",
				"or files where an accompanying file exists (in the same directory) with a \"-license\" suffix added",
				"to the base-name name of the original file, and an extension of txt, html, or similar. For example",
				"\"tidy\" is accompanied by \"tidy-license.txt\"."
			],
			"license": "TextMate Bundle License",
			"version": "0.0.0"
		}
	],
	"version": 1
}

<|start_filename|>src/vs/workbench/contrib/callHierarchy/browser/media/callHierarchy.css<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

.monaco-workbench .call-hierarchy .results,
.monaco-workbench .call-hierarchy .message {
	display: none;
}

.monaco-workbench .call-hierarchy[data-state="data"] .results {
	display: inherit;
	height: 100%;
}

.monaco-workbench .call-hierarchy[data-state="message"] .message {
	display: flex;
	align-items: center;
	justify-content: center;
	height: 100%;
}

.monaco-workbench .call-hierarchy .editor,
.monaco-workbench .call-hierarchy .tree {
	height: 100%;
}

.monaco-workbench .call-hierarchy .tree .callhierarchy-element {
	display: flex;
	flex: 1;
	flex-flow: row nowrap;
	align-items: center;
}

.monaco-workbench .call-hierarchy .tree .callhierarchy-element .monaco-icon-label {
	padding-left: 4px;
}


<|start_filename|>extensions/rust/package.nls.json<|end_filename|>
{
	"displayName": "Rust Language Basics",
	"description": "Provides syntax highlighting and bracket matching in Rust files."
}

<|start_filename|>build/polyfills/vscode-nls.js<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

'use strict';
Object.defineProperty(exports, "__esModule", { value: true });

function format(message, args) {
	let result;
	// if (isPseudo) {
	// 	// FF3B and FF3D is the Unicode zenkaku representation for [ and ]
	// 	message = '\uFF3B' + message.replace(/[aouei]/g, '$&$&') + '\uFF3D';
	// }
	if (args.length === 0) {
		result = message;
	}
	else {
		result = message.replace(/\{(\d+)\}/g, function (match, rest) {
			let index = rest[0];
			let arg = args[index];
			let replacement = match;
			if (typeof arg === 'string') {
				replacement = arg;
			}
			else if (typeof arg === 'number' || typeof arg === 'boolean' || arg === void 0 || arg === null) {
				replacement = String(arg);
			}
			return replacement;
		});
	}
	return result;
}

function localize(key, message) {
	let args = [];
	for (let _i = 2; _i < arguments.length; _i++) {
		args[_i - 2] = arguments[_i];
	}
	return format(message, args);
}

function loadMessageBundle(file) {
	return localize;
}

let MessageFormat;
(function (MessageFormat) {
	MessageFormat["file"] = "file";
	MessageFormat["bundle"] = "bundle";
	MessageFormat["both"] = "both";
})(MessageFormat = exports.MessageFormat || (exports.MessageFormat = {}));
let BundleFormat;
(function (BundleFormat) {
	// the nls.bundle format
	BundleFormat["standalone"] = "standalone";
	BundleFormat["languagePack"] = "languagePack";
})(BundleFormat = exports.BundleFormat || (exports.BundleFormat = {}));

exports.loadMessageBundle = loadMessageBundle;
function config(opts) {
	if (opts) {
		if (isString(opts.locale)) {
			options.locale = opts.locale.toLowerCase();
			options.language = options.locale;
			resolvedLanguage = undefined;
			resolvedBundles = Object.create(null);
		}
		if (opts.messageFormat !== undefined) {
			options.messageFormat = opts.messageFormat;
		}
		if (opts.bundleFormat === BundleFormat.standalone && options.languagePackSupport === true) {
			options.languagePackSupport = false;
		}
	}
	isPseudo = options.locale === 'pseudo';
	return loadMessageBundle;
}
exports.config = config;


<|start_filename|>src/vs/code/electron-sandbox/proxy/auth.js<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

'use strict';

const { ipcRenderer } = window.vscode;

function promptForCredentials(data) {
	return new Promise((c, e) => {
		const $title = document.getElementById('title');
		const $username = document.getElementById('username');
		const $password = document.getElementById('password');
		const $form = document.getElementById('form');
		const $cancel = document.getElementById('cancel');
		const $message = document.getElementById('message');

		function submit() {
			c({ username: $username.value, password: $password.value });
			return false;
		}

		function cancel() {
			c({ username: '', password: '' });
			return false;
		}

		$form.addEventListener('submit', submit);
		$cancel.addEventListener('click', cancel);

		document.body.addEventListener('keydown', function (e) {
			switch (e.keyCode) {
				case 27: e.preventDefault(); e.stopPropagation(); return cancel();
				case 13: e.preventDefault(); e.stopPropagation(); return submit();
			}
		});

		$title.textContent = data.title;
		$message.textContent = data.message;
		$username.focus();
	});
}

ipcRenderer.on('vscode:openProxyAuthDialog', async (event, data) => {
	const response = await promptForCredentials(data);
	ipcRenderer.send('vscode:proxyAuthResponse', response);
});


<|start_filename|>src/vs/workbench/contrib/files/browser/views/media/openeditors.css<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

.open-editors .monaco-list .monaco-list-row:hover > .monaco-action-bar,
.open-editors .monaco-list .monaco-list-row.focused > .monaco-action-bar,
.open-editors .monaco-list .monaco-list-row.dirty > .monaco-action-bar,
.open-editors .monaco-list .monaco-list-row.sticky > .monaco-action-bar {
	visibility: visible;
}

.open-editors .monaco-list .monaco-list-row > .monaco-action-bar .action-label {
	display: block;
}

.open-editors .monaco-list .monaco-list-row > .monaco-action-bar .codicon {
	color: inherit;
}

.open-editors .monaco-list .monaco-list-row > .monaco-action-bar .codicon-close,
.open-editors .monaco-list .monaco-list-row > .monaco-action-bar .codicon-pinned {
	width: 8px;
	height: 22px;
	display: flex;
	align-items: center;
	justify-content: center;
}

.open-editors .monaco-list .monaco-list-row.dirty:not(:hover) > .monaco-action-bar .codicon-pinned::before {
	content: "\ebb2"; /* use `pinned-dirty` icon unicode for sticky-dirty indication */
}

.open-editors .monaco-list .monaco-list-row.dirty:not(:hover) > .monaco-action-bar .codicon-close::before {
	content: "\ea71"; /* use `circle-filled` icon unicode for dirty indication */
}

.open-editors .monaco-list .monaco-list-row > .monaco-action-bar .action-close-all-files,
.open-editors .monaco-list .monaco-list-row > .monaco-action-bar .save-all {
	width: 23px;
	height: 22px;
}

.open-editors .monaco-list .monaco-list-row > .open-editor {
	flex: 1;
}

.open-editors .monaco-list .monaco-list-row > .editor-group {
	flex: 1;
}

.open-editors .monaco-list .monaco-list-row {
	padding-left: 22px;
	display: flex;
}

.open-editors .monaco-list .monaco-list-row > .monaco-action-bar {
	visibility: hidden;
	display: flex;
	align-items: center;
}

.open-editors .monaco-list .monaco-list-row .editor-group {
	font-size: 11px;
	font-weight: bold;
	text-transform: uppercase;
	cursor: default;
}

/* Bold font style does not go well with CJK fonts */
.composite:lang(zh-Hans) .open-editors .monaco-list .monaco-list-row .editor-group,
.composite:lang(zh-Hant) .open-editors .monaco-list .monaco-list-row .editor-group,
.composite:lang(ja) .open-editors .monaco-list .monaco-list-row .editor-group,
.composite:lang(ko) .open-editors .monaco-list .monaco-list-row .editor-group {
	font-weight: normal;
}

.open-editors .open-editor,
.open-editors .editor-group {
	height: 22px;
	line-height: 22px;
}

.open-editors .open-editor > a,
.open-editors .editor-group {
	text-overflow: ellipsis;
	overflow: hidden;
}

.monaco-workbench.hc-black .open-editors .open-editor,
.monaco-workbench.hc-black .open-editors .editor-group {
	line-height: 20px;
}


<|start_filename|>extensions/yaml/package.nls.json<|end_filename|>
{
	"displayName": "YAML Language Basics",
	"description": "Provides syntax highlighting and bracket matching in YAML files."
}

<|start_filename|>extensions/pug/package.nls.json<|end_filename|>
{
	"displayName": "Pug Language Basics",
	"description": "Provides syntax highlighting and bracket matching in Pug files."
}

<|start_filename|>extensions/objective-c/package.nls.json<|end_filename|>
{
	"displayName": "Objective-C Language Basics",
	"description": "Provides syntax highlighting and bracket matching in Objective-C files."
}

<|start_filename|>extensions/bat/package.nls.json<|end_filename|>
{
	"displayName": "Windows Bat Language Basics",
	"description": "Provides snippets, syntax highlighting, bracket matching and folding in Windows batch files."
}

<|start_filename|>extensions/github/package.nls.json<|end_filename|>
{
	"displayName": "GitHub",
	"description": "GitHub",
	"config.gitAuthentication": "Controls whether to enable automatic GitHub authentication for git commands within VS Code.",
	"welcome.publishFolder": "You can also directly publish this folder to a GitHub repository. Once published, you'll have access to source control features powered by git and GitHub.\n[$(github) Publish to GitHub](command:github.publish)",
	"welcome.publishWorkspaceFolder": "You can also directly publish a workspace folder to a GitHub repository. Once published, you'll have access to source control features powered by git and GitHub.\n[$(github) Publish to GitHub](command:github.publish)"
}


<|start_filename|>extensions/log/package.nls.json<|end_filename|>
{
	"displayName": "Log",
	"description": "Provides syntax highlighting for files with .log extension."
}

<|start_filename|>extensions/groovy/package.nls.json<|end_filename|>
{
	"displayName": "Groovy Language Basics",
	"description": "Provides snippets, syntax highlighting and bracket matching in Groovy files."
}

<|start_filename|>build/npm/update-distro.js<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

const cp = require('child_process');
const path = require('path');
const fs = require('fs');

const rootPath = path.dirname(path.dirname(path.dirname(__dirname)));
const vscodePath = path.join(rootPath, 'vscode');
const distroPath = path.join(rootPath, 'vscode-distro');
const commit = cp.execSync('git rev-parse HEAD', { cwd: distroPath, encoding: 'utf8' }).trim();
const packageJsonPath = path.join(vscodePath, 'package.json');
const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));

packageJson.distro = commit;
fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));

<|start_filename|>extensions/git/test/colorize-results/example_diff.json<|end_filename|>
[
	{
		"c": "diff --git a/helloworld.txt b/helloworld.txt",
		"t": "source.diff meta.diff.header.git",
		"r": {
			"dark_plus": "meta.diff.header: #569CD6",
			"light_plus": "meta.diff.header: #000080",
			"dark_vs": "meta.diff.header: #569CD6",
			"light_vs": "meta.diff.header: #000080",
			"hc_black": "meta.diff.header: #000080"
		}
	},
	{
		"c": "index e4f37c4..557db03 100644",
		"t": "source.diff meta.diff.index.git",
		"r": {
			"dark_plus": "default: #D4D4D4",
			"light_plus": "default: #000000",
			"dark_vs": "default: #D4D4D4",
			"light_vs": "default: #000000",
			"hc_black": "default: #FFFFFF"
		}
	},
	{
		"c": "---",
		"t": "source.diff meta.diff.header.from-file punctuation.definition.from-file.diff",
		"r": {
			"dark_plus": "meta.diff.header: #569CD6",
			"light_plus": "meta.diff.header: #000080",
			"dark_vs": "meta.diff.header: #569CD6",
			"light_vs": "meta.diff.header: #000080",
			"hc_black": "meta.diff.header: #000080"
		}
	},
	{
		"c": " a/helloworld.txt",
		"t": "source.diff meta.diff.header.from-file",
		"r": {
			"dark_plus": "meta.diff.header: #569CD6",
			"light_plus": "meta.diff.header: #000080",
			"dark_vs": "meta.diff.header: #569CD6",
			"light_vs": "meta.diff.header: #000080",
			"hc_black": "meta.diff.header: #000080"
		}
	},
	{
		"c": "+++",
		"t": "source.diff meta.diff.header.to-file punctuation.definition.to-file.diff",
		"r": {
			"dark_plus": "meta.diff.header: #569CD6",
			"light_plus": "meta.diff.header: #000080",
			"dark_vs": "meta.diff.header: #569CD6",
			"light_vs": "meta.diff.header: #000080",
			"hc_black": "meta.diff.header: #000080"
		}
	},
	{
		"c": " b/helloworld.txt",
		"t": "source.diff meta.diff.header.to-file",
		"r": {
			"dark_plus": "meta.diff.header: #569CD6",
			"light_plus": "meta.diff.header: #000080",
			"dark_vs": "meta.diff.header: #569CD6",
			"light_vs": "meta.diff.header: #000080",
			"hc_black": "meta.diff.header: #000080"
		}
	},
	{
		"c": "@@",
		"t": "source.diff meta.diff.range.unified punctuation.definition.range.diff",
		"r": {
			"dark_plus": "default: #D4D4D4",
			"light_plus": "default: #000000",
			"dark_vs": "default: #D4D4D4",
			"light_vs": "default: #000000",
			"hc_black": "default: #FFFFFF"
		}
	},
	{
		"c": " ",
		"t": "source.diff meta.diff.range.unified",
		"r": {
			"dark_plus": "default: #D4D4D4",
			"light_plus": "default: #000000",
			"dark_vs": "default: #D4D4D4",
			"light_vs": "default: #000000",
			"hc_black": "default: #FFFFFF"
		}
	},
	{
		"c": "-1 +1",
		"t": "source.diff meta.diff.range.unified meta.toc-list.line-number.diff",
		"r": {
			"dark_plus": "default: #D4D4D4",
			"light_plus": "default: #000000",
			"dark_vs": "default: #D4D4D4",
			"light_vs": "default: #000000",
			"hc_black": "default: #FFFFFF"
		}
	},
	{
		"c": " ",
		"t": "source.diff meta.diff.range.unified",
		"r": {
			"dark_plus": "default: #D4D4D4",
			"light_plus": "default: #000000",
			"dark_vs": "default: #D4D4D4",
			"light_vs": "default: #000000",
			"hc_black": "default: #FFFFFF"
		}
	},
	{
		"c": "@@",
		"t": "source.diff meta.diff.range.unified punctuation.definition.range.diff",
		"r": {
			"dark_plus": "default: #D4D4D4",
			"light_plus": "default: #000000",
			"dark_vs": "default: #D4D4D4",
			"light_vs": "default: #000000",
			"hc_black": "default: #FFFFFF"
		}
	},
	{
		"c": "-",
		"t": "source.diff markup.deleted.diff punctuation.definition.deleted.diff",
		"r": {
			"dark_plus": "markup.deleted: #CE9178",
			"light_plus": "markup.deleted: #A31515",
			"dark_vs": "markup.deleted: #CE9178",
			"light_vs": "markup.deleted: #A31515",
			"hc_black": "markup.deleted: #CE9178"
		}
	},
	{
		"c": "Hello world",
		"t": "source.diff markup.deleted.diff",
		"r": {
			"dark_plus": "markup.deleted: #CE9178",
			"light_plus": "markup.deleted: #A31515",
			"dark_vs": "markup.deleted: #CE9178",
			"light_vs": "markup.deleted: #A31515",
			"hc_black": "markup.deleted: #CE9178"
		}
	},
	{
		"c": "+",
		"t": "source.diff markup.inserted.diff punctuation.definition.inserted.diff",
		"r": {
			"dark_plus": "markup.inserted: #B5CEA8",
			"light_plus": "markup.inserted: #098658",
			"dark_vs": "markup.inserted: #B5CEA8",
			"light_vs": "markup.inserted: #098658",
			"hc_black": "markup.inserted: #B5CEA8"
		}
	},
	{
		"c": "Hello World",
		"t": "source.diff markup.inserted.diff",
		"r": {
			"dark_plus": "markup.inserted: #B5CEA8",
			"light_plus": "markup.inserted: #098658",
			"dark_vs": "markup.inserted: #B5CEA8",
			"light_vs": "markup.inserted: #098658",
			"hc_black": "markup.inserted: #B5CEA8"
		}
	}
]


<|start_filename|>src/vs/editor/contrib/documentSymbols/media/symbol-icons.css<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

.monaco-icon-label.deprecated {
	text-decoration: line-through;
	opacity: 0.66;
}


<|start_filename|>extensions/html-language-features/server/extension-browser.webpack.config.js<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

//@ts-check

'use strict';

const withBrowserDefaults = require('../../shared.webpack.config').browser;
const path = require('path');

const serverConfig = withBrowserDefaults({
	context: __dirname,
	entry: {
		extension: './src/browser/htmlServerMain.ts',
	},
	output: {
		filename: 'htmlServerMain.js',
		path: path.join(__dirname, 'dist', 'browser'),
		libraryTarget: 'var'
	},
	optimization: {
		splitChunks: {
			chunks: 'async'
		}
	}
});
serverConfig.module.noParse =  /typescript[\/\\]lib[\/\\]typescript\.js/;
serverConfig.module.rules.push({
	test: /javascriptLibs.ts$/,
	use: [
		{
			loader: path.resolve(__dirname, 'build', 'javaScriptLibraryLoader.js')
		}
	]
});

module.exports = serverConfig;


<|start_filename|>test/ui/splitview/server.js<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

const fs = require('mz/fs');
const path = require('path');
const Koa = require('koa');
const _ = require('koa-route');
const serve = require('koa-static');
const mount = require('koa-mount');

const app = new Koa();

app.use(serve('public'));
app.use(mount('/static', serve('../../out')));

app.listen(3000);
console.log('http://localhost:3000');

<|start_filename|>build/polyfills/vscode-extension-telemetry.js<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

'use strict';
Object.defineProperty(exports, "__esModule", { value: true });

let TelemetryReporter = (function () {
	function TelemetryReporter(extensionId, extensionVersion, key) {
	}
	TelemetryReporter.prototype.updateUserOptIn = function (key) {
	};
	TelemetryReporter.prototype.createAppInsightsClient = function (key) {
	};
	TelemetryReporter.prototype.getCommonProperties = function () {
	};
	TelemetryReporter.prototype.sendTelemetryEvent = function (eventName, properties, measurements) {
	};
	TelemetryReporter.prototype.dispose = function () {
	};
	TelemetryReporter.TELEMETRY_CONFIG_ID = 'telemetry';
	TelemetryReporter.TELEMETRY_CONFIG_ENABLED_ID = 'enableTelemetry';
	return TelemetryReporter;
}());
exports.default = TelemetryReporter;


<|start_filename|>src/vs/workbench/contrib/terminal/browser/media/scrollbar.css<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

.monaco-workbench .pane-body.integrated-terminal .xterm-viewport {
	/* Use the hack presented in https://stackoverflow.com/a/38748186/1156119 to get opacity transitions working on the scrollbar */
	-webkit-background-clip: text;
	background-clip: text;
	-webkit-text-fill-color: transparent;
	transition: background-color 800ms linear;
}

.monaco-workbench .pane-body.integrated-terminal .xterm-viewport::-webkit-scrollbar {
	width: 10px;
}

.monaco-workbench .pane-body.integrated-terminal .xterm-viewport::-webkit-scrollbar-track {
	opacity: 0;
}

.monaco-workbench .pane-body.integrated-terminal .xterm-viewport::-webkit-scrollbar-thumb {
	min-height: 20px;
	background-color: inherit;
}

.monaco-workbench .pane-body.integrated-terminal .find-focused .xterm .xterm-viewport,
.monaco-workbench .pane-body.integrated-terminal .xterm.focus .xterm-viewport,
.monaco-workbench .pane-body.integrated-terminal .xterm:focus .xterm-viewport,
.monaco-workbench .pane-body.integrated-terminal .xterm:hover .xterm-viewport {
	transition: opacity 100ms linear;
	cursor: default;
}

.monaco-workbench .pane-body.integrated-terminal .xterm .xterm-viewport::-webkit-scrollbar-thumb:hover {
	transition: opacity 0ms linear;
}

.monaco-workbench .pane-body.integrated-terminal .xterm .xterm-viewport::-webkit-scrollbar-thumb:window-inactive {
	background-color: inherit;
}


<|start_filename|>src/vs/workbench/contrib/webview/browser/pre/host.js<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
// @ts-check
(function () {
	const id = document.location.search.match(/\bid=([\w-]+)/)[1];
	const onElectron = /platform=electron/.test(document.location.search);

	const hostMessaging = new class HostMessaging {
		constructor() {
			this.handlers = new Map();
			window.addEventListener('message', (e) => {
				if (e.data && (e.data.command === 'onmessage' || e.data.command === 'do-update-state')) {
					// Came from inner iframe
					this.postMessage(e.data.command, e.data.data);
					return;
				}

				const channel = e.data.channel;
				const handler = this.handlers.get(channel);
				if (handler) {
					handler(e, e.data.args);
				} else {
					console.log('no handler for ', e);
				}
			});
		}

		postMessage(channel, data) {
			window.parent.postMessage({ target: id, channel, data }, '*');
		}

		onMessage(channel, handler) {
			this.handlers.set(channel, handler);
		}
	}();

	function fatalError(/** @type {string} */ message) {
		console.error(`Webview fatal error: ${message}`);
		hostMessaging.postMessage('fatal-error', { message });
	}

	const workerReady = new Promise(async (resolveWorkerReady) => {
		if (onElectron) {
			return resolveWorkerReady();
		}

		if (!areServiceWorkersEnabled()) {
			fatalError('Service Workers are not enabled in browser. Webviews will not work.');
			return resolveWorkerReady();
		}

		const expectedWorkerVersion = 1;

		navigator.serviceWorker.register('service-worker.js').then(
			async registration => {
				await navigator.serviceWorker.ready;

				const versionHandler = (event) => {
					if (event.data.channel !== 'version') {
						return;
					}

					navigator.serviceWorker.removeEventListener('message', versionHandler);
					if (event.data.version === expectedWorkerVersion) {
						return resolveWorkerReady();
					} else {
						// If we have the wrong version, try once to unregister and re-register
						return registration.update()
							.then(() => navigator.serviceWorker.ready)
							.finally(resolveWorkerReady);
					}
				};
				navigator.serviceWorker.addEventListener('message', versionHandler);
				registration.active.postMessage({ channel: 'version' });
			},
			error => {
				fatalError(`Could not register service workers: ${error}.`);
				resolveWorkerReady();
			});

		const forwardFromHostToWorker = (channel) => {
			hostMessaging.onMessage(channel, event => {
				navigator.serviceWorker.ready.then(registration => {
					registration.active.postMessage({ channel: channel, data: event.data.args });
				});
			});
		};
		forwardFromHostToWorker('did-load-resource');
		forwardFromHostToWorker('did-load-localhost');

		navigator.serviceWorker.addEventListener('message', event => {
			if (['load-resource', 'load-localhost'].includes(event.data.channel)) {
				hostMessaging.postMessage(event.data.channel, event.data);
			}
		});
	});

	function areServiceWorkersEnabled() {
		try {
			return !!navigator.serviceWorker;
		} catch (e) {
			return false;
		}
	}

	/** @type {import('./main').WebviewHost} */
	const host = {
		postMessage: hostMessaging.postMessage.bind(hostMessaging),
		onMessage: hostMessaging.onMessage.bind(hostMessaging),
		ready: workerReady,
		fakeLoad: !onElectron,
		onElectron: onElectron,
		rewriteCSP: onElectron
			? (csp) => {
				return csp.replace(/vscode-resource:(?=(\s|;|$))/g, 'vscode-webview-resource:');
			}
			: (csp, endpoint) => {
				const endpointUrl = new URL(endpoint);
				return csp.replace(/(vscode-webview-resource|vscode-resource):(?=(\s|;|$))/g, endpointUrl.origin);
			}
	};

	(/** @type {any} */ (window)).createWebviewManager(host);
}());


<|start_filename|>src/vs/workbench/contrib/notebook/browser/contrib/find/media/notebookFind.css<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

.monaco-workbench .notebookOverlay.notebook-editor.find-hide-transition {
	overflow-y: hidden;
}

.monaco-workbench .notebookOverlay.notebook-editor.find-show-transition {
	overflow-y: hidden;
}


<|start_filename|>test/unit/node/css.mock.js<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

define([], function() {
	return {
		load: function(name, req, load) {
			load({});
		}
	};
});


<|start_filename|>src/vs/workbench/contrib/comments/browser/media/review.css<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

.monaco-editor .review-widget {
	width: 100%;
	position: absolute;
}

.monaco-editor .review-widget .hidden {
	display: none !important;
}

.monaco-editor .review-widget .body {
	overflow: hidden;
}

.monaco-editor .review-widget .body .review-comment {
	padding: 8px 16px 8px 20px;
	display: flex;
}

.monaco-editor .review-widget .body .review-comment .comment-actions {
	margin-left: auto;
}

.monaco-editor .review-widget .body .review-comment .comment-actions .monaco-toolbar {
	height: 21px;
}

.monaco-editor .review-widget .body .review-comment .comment-title {
	display: flex;
	width: 100%;
}

.monaco-editor .review-widget .body .review-comment .comment-title .action-label.codicon {
	line-height: 18px;
}

.monaco-editor .review-widget .body .review-comment .comment-title .monaco-dropdown .toolbar-toggle-more {
	width: 16px;
	height: 18px;
	line-height: 18px;
	vertical-align: middle;
}

.monaco-editor .review-widget .body .comment-body blockquote {
	margin: 0 7px 0 5px;
	padding: 0 16px 0 10px;
	border-left-width: 5px;
	border-left-style: solid;
}

.monaco-editor .review-widget .body .review-comment .avatar-container {
	margin-top: 4px !important;
}

.monaco-editor .review-widget .body .review-comment .avatar-container img.avatar {
	height: 28px;
	width: 28px;
	display: inline-block;
	overflow: hidden;
	line-height: 1;
	vertical-align: middle;
	border-radius: 3px;
	border-style: none;
}

.monaco-editor .review-widget .body .comment-reactions .monaco-text-button {
	margin: 0 7px 0 0;
	width: 30px;
	background-color: transparent;
	border: 1px solid grey;
	border-radius: 3px;
}

.monaco-editor .review-widget .body .review-comment .review-comment-contents {
	padding-left: 20px;
	user-select: text;
	-webkit-user-select: text;
	width: 100%;
	overflow: hidden;
}

.monaco-editor .review-widget .body pre {
	overflow: auto;
	word-wrap: normal;
	white-space: pre;
}


.monaco-editor .review-widget .body .review-comment .review-comment-contents .author {
	line-height: 22px;
}


.monaco-editor .review-widget .body .review-comment .review-comment-contents .isPending {
	margin: 0 5px 0 5px;
	padding: 0 2px 0 2px;
	font-style: italic;
}

.monaco-editor .review-widget .body .review-comment .review-comment-contents .comment-body {
	padding-top: 4px;
}

.monaco-editor .review-widget .body .review-comment .review-comment-contents .comment-reactions {
	margin-top: 8px;
	min-height: 25px;
}

.monaco-editor .review-widget .body .review-comment .review-comment-contents .comment-reactions .monaco-action-bar .actions-container {
	justify-content: flex-start;
}

.monaco-editor .review-widget .body .review-comment .review-comment-contents .comment-reactions .action-item .action-label {
	padding: 1px 4px;
	white-space: pre;
	text-align: center;
	font-size: 12px;
	display: flex;
}

.monaco-editor .review-widget .body .review-comment .review-comment-contents .comment-reactions .action-item .action-label .reaction-icon {
	background-size: 14px;
	background-position: left center;
	background-repeat: no-repeat;
	width: 14px;
	-webkit-font-smoothing: antialiased;
	-moz-osx-font-smoothing: grayscale;
	display: inline-block;
	margin-right: 4px;
}

.monaco-editor .review-widget .body .review-comment .review-comment-contents .comment-reactions .action-item .action-label .reaction-label {
	line-height: 20px;
	margin-right: 4px;
}

.monaco-editor .review-widget .body .review-comment .review-comment-contents .comment-reactions .action-item a.action-label.toolbar-toggle-pickReactions {
	display: none;
	background-size: 16px;
	width: 26px;
	height: 16px;
	background-repeat: no-repeat;
	background-position: center;
	margin-top: 3px;
	border: none;
}

.monaco-editor .review-widget .body .review-comment .review-comment-contents .comment-reactions:hover .action-item a.action-label.toolbar-toggle-pickReactions {
	display: inline-block;
	background-size: 16px;
}

.monaco-editor .review-widget .body .review-comment .comment-title .action-label {
	display: block;
	height: 16px;
	line-height: 16px;
	background-size: 16px;
	background-position: center center;
	background-repeat: no-repeat;
}

.monaco-editor .review-widget .body .review-comment .review-comment-contents .comment-reactions .action-item a.action-label {
	border: 1px solid;
}

.monaco-editor .review-widget .body .review-comment .review-comment-contents .comment-reactions .action-item a.action-label.disabled {
	opacity: 0.6;
}

.monaco-editor .review-widget .body .comment-body p,
.monaco-editor .review-widget .body .comment-body ul {
	margin: 8px 0;
}

.monaco-editor .review-widget .body .comment-body p:first-child,
.monaco-editor .review-widget .body .comment-body ul:first-child {
	margin-top: 0;
}

.monaco-editor .review-widget .body .comment-body p:last-child,
.monaco-editor .review-widget .body.comment-body ul:last-child {
	margin-bottom: 0;
}

.monaco-editor .review-widget .body .comment-body ul {
	padding-left: 20px;
}

.monaco-editor .review-widget .body .comment-body li > p {
	margin-bottom: 0;
}

.monaco-editor .review-widget .body .comment-body li > ul {
	margin-top: 0;
}

.monaco-editor .review-widget .body .comment-body code {
	border-radius: 3px;
	padding: 0 0.4em;
}

.monaco-editor .review-widget .body .comment-body span {
	white-space: pre;
}

.monaco-editor .review-widget .body .comment-body img {
	max-width: 100%;
}

.monaco-editor .review-widget .body .comment-form {
	margin: 8px 20px;
}

.monaco-editor .review-widget .validation-error {
	display: inline-block;
	overflow: hidden;
	text-align: left;
	width: 100%;
	box-sizing: border-box;
	padding: 0.4em;
	font-size: 12px;
	line-height: 17px;
	min-height: 34px;
	margin-top: -1px;
	margin-left: -1px;
	word-wrap: break-word;
}

.monaco-editor .review-widget .body .comment-form.expand .review-thread-reply-button {
	display: none;
}

.monaco-editor .review-widget .body .comment-form.expand .monaco-editor,
.monaco-editor .review-widget .body .comment-form.expand .form-actions {
	display: block;
	box-sizing: content-box;
}

.monaco-editor .review-widget .body .comment-form .review-thread-reply-button {
	text-align: left;
	display: block;
	width: 100%;
	resize: vertical;
	border-radius: 0;
	box-sizing: border-box;
	padding: 6px 12px;
	font-weight: 600;
	line-height: 20px;
	white-space: nowrap;
	border: 0px;
	outline: 1px solid transparent;
}

.monaco-editor .review-widget .body .comment-form .review-thread-reply-button:focus {
	outline-style: solid;
	outline-width: 1px;
}

.monaco-editor .review-widget .body .comment-form .monaco-editor,
.monaco-editor .review-widget .body .edit-container .monaco-editor {
	width: 100%;
	min-height: 90px;
	max-height: 500px;
	border-radius: 3px;
	border: 0px;
	box-sizing: content-box;
	padding: 6px 0 6px 12px;
}

.monaco-editor .review-widget .body .comment-form .monaco-editor,
.monaco-editor .review-widget .body .comment-form .form-actions {
	display: none;
}

.monaco-editor .review-widget .body .comment-form .form-actions,
.monaco-editor .review-widget .body .edit-container .form-actions {
	overflow: auto;
	padding: 10px 0;
}

.monaco-editor .review-widget .body .edit-container .form-actions {
	display: flex;
	justify-content: flex-end;
}

.monaco-editor .review-widget .body .edit-textarea {
	height: 90px;
	margin: 5px 0 10px 0;
}

.monaco-editor .review-widget .body .comment-form .monaco-text-button,
.monaco-editor .review-widget .body .edit-container .monaco-text-button {
	width: auto;
	padding: 4px 10px;
	margin-left: 5px;
	margin-bottom: 5px;
}

.monaco-editor .review-widget .body .comment-form .monaco-text-button {
	float: right;
}

.monaco-editor .review-widget .head {
	box-sizing: border-box;
	display: flex;
	height: 100%;
}

.monaco-editor .review-widget .head .review-title {
	display: inline-block;
	font-size: 13px;
	margin-left: 20px;
	cursor: default;
}

.monaco-editor .review-widget .head .review-title .dirname:not(:empty) {
	font-size: 0.9em;
	margin-left: 0.5em;
}

.monaco-editor .review-widget .head .review-actions {
	flex: 1;
	text-align: right;
	padding-right: 2px;
}

.monaco-editor .review-widget .head .review-actions > .monaco-action-bar {
	display: inline-block;
}

.monaco-editor .review-widget .head .review-actions > .monaco-action-bar,
.monaco-editor .review-widget .head .review-actions > .monaco-action-bar > .actions-container {
	height: 100%;
}

.monaco-editor .review-widget .action-item {
	min-width: 18px;
	min-height: 20px;
	margin-left: 4px;
}

.monaco-editor .review-widget .head .review-actions > .monaco-action-bar .action-label {
	width: 16px;
	height: 100%;
	margin: 0;
	line-height: inherit;
	background-repeat: no-repeat;
	background-position: center center;
}

.monaco-editor .review-widget .head .review-actions > .monaco-action-bar .action-label.codicon {
	margin: 0;
}

.monaco-editor .review-widget > .body {
	border-top: 1px solid;
	position: relative;
}

.monaco-editor .comment-range-glyph {
	margin-left: 5px;
	width: 4px !important;
	cursor: pointer;
	z-index: 10;
}

div.preview.inline .monaco-editor .comment-range-glyph {
	display: none !important;
}

.monaco-editor .comment-range-glyph:before {
	position: absolute;
	content: "";
	height: 100%;
	width: 0;
	left: -2px;
	transition: width 80ms linear, left 80ms linear;
}

.monaco-editor .margin-view-overlays > div:hover > .comment-range-glyph.comment-diff-added:before,
.monaco-editor .comment-range-glyph.comment-thread:before {
	position: absolute;
	height: 100%;
	width: 9px;
	left: -6px;
	z-index: 10;
	color: black;
	text-align: center;
	display: flex;
	flex-direction: row;
	align-items: center;
	justify-content: center;
}

.monaco-editor .margin-view-overlays > div:hover > .comment-range-glyph.comment-diff-added:before {
	content: "+";
}

.monaco-editor .comment-range-glyph.comment-thread {
	z-index: 20;
}

.monaco-editor .comment-range-glyph.comment-thread:before {
	content: "◆";
	font-size: 10px;
	line-height: 100%;
	z-index: 20;
}

.monaco-editor.inline-comment .margin-view-overlays .folding {
	margin-left: 7px;
}

.monaco-editor.inline-comment .margin-view-overlays .dirty-diff-glyph {
	margin-left: 14px;
}


<|start_filename|>extensions/docker/package.nls.json<|end_filename|>
{
	"displayName": "Docker Language Basics",
	"description": "Provides syntax highlighting and bracket matching in Docker files."
}

<|start_filename|>src/vs/code/electron-sandbox/issue/issueReporter.js<|end_filename|>
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

//@ts-check
'use strict';

(function () {
	const bootstrapWindow = bootstrapWindowLib();

	// Load issue reporter into window
	bootstrapWindow.load(['vs/code/electron-sandbox/issue/issueReporterMain'], function (issueReporter, configuration) {
		issueReporter.startup(configuration);
	}, { forceEnableDeveloperKeybindings: true, disallowReloadKeybinding: true });


	//#region Globals

	/**
	 * @returns {{ load: (modules: string[], resultCallback: (result, configuration: object) => any, options?: object) => unknown }}
	 */
	function bootstrapWindowLib() {
		// @ts-ignore (defined in bootstrap-window.js)
		return window.MonacoBootstrapWindow;
	}

	//#endregion
}());
