text: /*---------------------------------------------------------------------------------------------
   *  Copyright (c) Microsoft Corporation. All rights reserved.
   *  Licensed under the MIT License. See License.txt in the project root for license information.
   *--------------------------------------------------------------------------------------------*/
  
  //@ts-check
  
  /** @typedef {import('../build/utils').IFile} IFile */
  
  const glob = require('glob');
  const path = require('path');
  const fs = require('fs');
  const cp = require('child_process');
  const CleanCSS = require('clean-css');
  const { REPO_ROOT, removeDir, readFiles, writeFiles } = require('./utils');
  
  /** @type {string} */
  const MONACO_EDITOR_VERSION = (() => {
  	const packageJsonPath = path.join(REPO_ROOT, 'package.json');
  	const packageJson = JSON.parse(fs.readFileSync(packageJsonPath).toString());
  	const version = packageJson.version;
  	if (!/\d+\.\d+\.\d+/.test(version)) {
  		console.log('unrecognized package.json version: ' + version);
  		process.exit(1);
  	}
  	return version;
  })();
  
  removeDir(`../monaco-editor-website`);
  checkSamples();
  generateWebsite();
  
  /**
   * Check that there are samples for all available languages
   */
  function checkSamples() {
  	let languages = glob
  		.sync('src/basic-languages/*/*.contribution.ts', { cwd: REPO_ROOT })
  		.map((f) => path.dirname(f))
  		.map((f) => f.substring('src/basic-languages/'.length));
  	languages.push('css');
  	languages.push('html');
  	languages.push('json');
  	languages.push('typescript');
  
  	// some languages have a different id than their folder
  	languages = languages.map((l) => {
  		switch (l) {
  			case 'coffee':
  				return 'coffeescript';
  			case 'protobuf':
  				return 'proto';
  			case 'solidity':
  				return 'sol';
  			case 'sophia':
  				return 'aes';
  			default:
  				return l;
  		}
  	});
  
  	let fail = false;
  	for (const language of languages) {
  		const expectedSamplePath = path.join(REPO_ROOT, `website/index/samples/sample.${language}.txt`);
  		if (!fs.existsSync(expectedSamplePath)) {
  			console.error(`Missing sample for ${language} at ${expectedSamplePath}`);
  			fail = true;
  		}
  	}
  	if (fail) {
  		process.exit(1);
  	}
  }
  
  /**
   * @param {string} dataPath
   * @param {string} contents
   * @param {RegExp} regex
   * @param {(match:string, fileContents:Buffer)=>string} callback
   * @returns {string}
   */
  function replaceWithRelativeResource(dataPath, contents, regex, callback) {
  	return contents.replace(regex, function (_, m0) {
  		const filePath = path.join(REPO_ROOT, 'website', path.dirname(dataPath), m0);
  		return callback(m0, fs.readFileSync(filePath));
  	});
  }
  
  function generateWebsite() {
  	const files = readFiles('website/**/*', {
  		base: 'website',
  		ignore: ['website/typedoc/**/*'],
  		dot: true
  	});
  
  	for (const file of files) {
  		if (!file.contents || !/\.(html)$/.test(file.path) || /new-samples/.test(file.path)) {
  			continue;
  		}
  
  		let contents = file.contents.toString();
  		contents = contents.replace(/\.\.\/\.\.\/release\/dev/g, 'node_modules/monaco-editor/min');
  		// contents = contents.replace(/\.\.\/\.\.\/release\/dev/g, '../monaco-editor/release/dev');
  		contents = contents.replace(/{{version}}/g, MONACO_EDITOR_VERSION);
  		contents = contents.replace(/{{year}}/g, String(new Date().getFullYear()));
  
  		// Preload xhr contents
  		contents = replaceWithRelativeResource(
  			file.path,
  			contents,
  			/<pre data-preload="([^"]+)".*/g,
  			function (m0, fileContents) {
  				return (
  					'<pre data-preload="' +
  					m0 +
  					'" style="display:none">' +
  					fileContents
  						.toString('utf8')
  						.replace(/&/g, '&amp;')
  						.replace(/</g, '&lt;')
  						.replace(/>/g, '&gt;') +
  					'</pre>'
  				);
  			}
  		);
  
  		// Inline fork.png
  		contents = replaceWithRelativeResource(
  			file.path,
  			contents,
  			/src="(\.\/fork.png)"/g,
  			function (m0, fileContents) {
  				return 'src="data:image/png;base64,' + fileContents.toString('base64') + '"';
  			}
  		);
  
  		// let allCSS = '';
  		contents = replaceWithRelativeResource(
  			file.path,
  			contents,
  			/<link data-inline="yes-please" href="([^"]+)".*/g,
  			function (m0, fileContents) {
  				const minifiedCSS = new CleanCSS().minify(fileContents.toString('utf8')).styles;
  				return `<style>${minifiedCSS}</style>`;
  			}
  		);
  
  		// Inline javascript
  		contents = replaceWithRelativeResource(
  			file.path,
  			contents,
  			/<script data-inline="yes-please" src="([^"]+)".*/g,
  			function (m0, fileContents) {
  				return '<script>' + fileContents.toString('utf8') + '</script>';
  			}
  		);
  
  		file.contents = Buffer.from(contents.split(/\r\n|\r|\n/).join('\n'));
  	}
  
  	writeFiles(files, `../monaco-editor-website`);
  
  	// temporarily create package.json so that npm install doesn't bark
  	fs.writeFileSync(path.join(REPO_ROOT, '../monaco-editor-website/package.json'), '{}');
  	fs.writeFileSync(path.join(REPO_ROOT, '../monaco-editor-website/.nojekyll'), '');
  	cp.execSync('npm install monaco-editor', {
  		cwd: path.join(REPO_ROOT, '../monaco-editor-website')
  	});
  	fs.unlinkSync(path.join(REPO_ROOT, '../monaco-editor-website/package.json'));
  }
  