esm - more cleanup (#230285)

.eslintignore

@@ -31,7 +31,6 @@
 **/src/vs/base/test/common/filters.perf.data.js
 **/src/vs/loader.js
 **/test/unit/assert.js
-**/test/unit/assert-esm.js
 **/test/automation/out/**
 **/typings/**
 !.vscode

.eslintplugin/code-import-patterns.ts

@@ -249,7 +249,7 @@ export = new class implements eslint.Rule.RuleModule {
 			const relativeFilename = getRelativeFilename(context);
 			importPath = path.posix.join(path.posix.dirname(relativeFilename), importPath);
 			if (/^src\/vs\//.test(importPath)) {
-				// resolve using AMD base url
+				// resolve using base url
 				importPath = importPath.substring('src/'.length);
 			}
 		}

.eslintrc.json

@@ -2,7 +2,7 @@
 	"root": true,
 	"parser": "@typescript-eslint/parser",
 	"parserOptions": {
-		"ecmaVersion": 6,
+		"ecmaVersion": 2022,
 		"sourceType": "module"
 	},
 	"plugins": [
@@ -1132,7 +1132,13 @@
 						]
 					},
 					{
-						"target": "src/vs/{loader.d.ts,monaco.d.ts,nls.ts,nls.messages.ts}",
+						"target": "src/vs/nls.ts",
+						"restrictions": [
+							"vs/*"
+						]
+					},
+					{
+						"target": "src/vs/{monaco.d.ts,nls.ts,nls.messages.ts}",
 						"restrictions": []
 					},
 					{

build/filters.js

@@ -79,7 +79,6 @@ module.exports.indentationFilter = [
 	'!src/vs/base/node/cpuUsage.sh',
 	'!src/vs/editor/common/languages/highlights/*.scm',
 	'!test/unit/assert.js',
-	'!test/unit/assert-esm.js',
 	'!resources/linux/snap/electron-launch',
 	'!build/ext.js',
 	'!build/npm/gyp/patches/gyp_spectre_mitigation_support.patch',

build/lib/layersChecker.js

@@ -23,7 +23,6 @@ const minimatch_1 = require("minimatch");
 // Types we assume are present in all implementations of JS VMs (node.js, browsers)
 // Feel free to add more core types as you see needed if present in node.js and browsers
 const CORE_TYPES = [
-    'require', // from our AMD loader
     'setTimeout',
     'clearTimeout',
     'setInterval',

build/lib/layersChecker.ts

@@ -24,7 +24,6 @@ import { match } from 'minimatch';
 // Types we assume are present in all implementations of JS VMs (node.js, browsers)
 // Feel free to add more core types as you see needed if present in node.js and browsers
 const CORE_TYPES = [
-	'require', // from our AMD loader
 	'setTimeout',
 	'clearTimeout',
 	'setInterval',

build/lib/standalone.js

@@ -103,8 +103,7 @@ function extractEditor(options) {
     delete tsConfig.compilerOptions.moduleResolution;
     writeOutputFile('tsconfig.json', JSON.stringify(tsConfig, null, '\t'));
     [
-        'vs/loader.js',
+        'vs/loader.js'
-        'vs/loader.d.ts'
     ].forEach(copyFile);
 }
 function createESMSourcesAndResources2(options) {

build/lib/standalone.ts

@@ -115,8 +115,7 @@ export function extractEditor(options: tss.ITreeShakingOptions & { destRoot: str
 	writeOutputFile('tsconfig.json', JSON.stringify(tsConfig, null, '\t'));
 
 	[
-		'vs/loader.js',
+		'vs/loader.js'
-		'vs/loader.d.ts'
 	].forEach(copyFile);
 }
 

scripts/test-documentation.bat

@@ -5,7 +5,7 @@ echo Runs tests against the current documentation in https://github.com/microsof
 
 pushd %~dp0\..
 
-:: Endgame tests in AMD
+:: Endgame tests
 call .\scripts\test.bat --runGlob **\*.releaseTest.js %*
 if %errorlevel% neq 0 exit /b %errorlevel%
 

scripts/test-documentation.sh

@@ -14,7 +14,7 @@ cd $ROOT
 
 echo "Runs tests against the current documentation in https://github.com/microsoft/vscode-docs/tree/vnext"
 
-# Tests in AMD
+# Tests
 ./scripts/test.sh --runGlob **/*.releaseTest.js "$@"
 
 

scripts/test-integration.bat

@@ -25,7 +25,7 @@ echo Storing crash reports into '%VSCODECRASHDIR%'.
 echo Storing log files into '%VSCODELOGSDIR%'.
 
 
-:: Tests standalone (AMD)
+:: Unit tests
 
 echo.
 echo ### node.js integration tests

scripts/test-integration.sh

@@ -34,7 +34,7 @@ echo "Storing crash reports into '$VSCODECRASHDIR'."
 echo "Storing log files into '$VSCODELOGSDIR'."
 
 
-# Tests standalone (AMD)
+# Unit tests
 
 echo
 echo "### node.js integration tests"

src/main.ts

@@ -643,7 +643,7 @@ async function resolveNlsConfiguration(): Promise<INLSConfiguration> {
 }
 
 /**
- * Language tags are case insensitive however an amd loader is case sensitive
+ * Language tags are case insensitive however an ESM loader is case sensitive
  * To make this work on case preserving & insensitive FS we do the following:
  * the language bundles have lower case language tags and we always lower case
  * the locale we receive from the user or OS.

src/tsconfig.monaco.json

@@ -21,7 +21,6 @@
 		"typings/vscode-globals-product.d.ts",
 		"typings/vscode-globals-nls.d.ts",
 		"typings/editContext.d.ts",
-		"vs/loader.d.ts",
 		"vs/monaco.d.ts",
 		"vs/editor/*",
 		"vs/base/common/*",

src/vs/loader.d.ts

@@ -1,35 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-declare namespace AMDLoader {
-	interface ILoaderPlugin {
-		load: (pluginParam: string, parentRequire: IRelativeRequire, loadCallback: IPluginLoadCallback, options: IConfigurationOptions) => void;
-		write?: (pluginName: string, moduleName: string, write: IPluginWriteCallback) => void;
-		writeFile?: (pluginName: string, moduleName: string, req: IRelativeRequire, write: IPluginWriteFileCallback, config: IConfigurationOptions) => void;
-		finishBuild?: (write: (filename: string, contents: string) => void) => void;
-	}
-	interface IRelativeRequire {
-		(dependencies: string[], callback: Function, errorback?: (error: Error) => void): void;
-		toUrl(id: string): string;
-	}
-	interface IPluginLoadCallback {
-		(value: any): void;
-		error(err: any): void;
-	}
-	interface IConfigurationOptions {
-		isBuild: boolean | undefined;
-		[key: string]: any;
-	}
-	interface IPluginWriteCallback {
-		(contents: string): void;
-		getEntryPoint(): string;
-		asModule(moduleId: string, contents: string): void;
-	}
-	interface IPluginWriteFileCallback {
-		(filename: string, contents: string): void;
-		getEntryPoint(): string;
-		asModule(moduleId: string, contents: string): void;
-	}
-}

src/vs/nls.messages.ts

@@ -6,6 +6,8 @@
 /*
  * This module exists so that the AMD build of the monaco editor can replace this with an async loader plugin.
  * If you add new functions to this module make sure that they are also provided in the AMD build of the monaco editor.
+ *
+ * TODO@esm remove me once we no longer ship an AMD build.
  */
 
 export function getNLSMessages(): string[] {

src/vs/nls.ts

@@ -3,9 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-// eslint-disable-next-line local/code-import-patterns
 import { getNLSLanguage, getNLSMessages } from './nls.messages.js';
-// eslint-disable-next-line local/code-import-patterns
 export { getNLSLanguage, getNLSMessages } from './nls.messages.js';
 
 const isPseudo = getNLSLanguage() === 'pseudo' || (typeof document !== 'undefined' && document.location && typeof document.location.hash === 'string' && document.location.hash.indexOf('pseudo=true') >= 0);

src/vs/platform/utilityProcess/common/utilityProcessWorkerService.ts

@@ -81,7 +81,7 @@ export interface IUtilityProcessWorkerService {
 	 * end of the message port connection will be sent back to the calling window
 	 * as identified by the `reply` configuration.
 	 *
-	 * Requires the forked process to be AMD module that uses our IPC channel framework
+	 * Requires the forked process to be ES module that uses our IPC channel framework
 	 * to respond to the provided `channelName` as a server.
 	 *
 	 * The process will be automatically terminated when the receiver window closes,

src/vs/workbench/services/utilityProcess/electron-sandbox/utilityProcessWorkerWorkbenchService.ts

@@ -43,7 +43,7 @@ export interface IUtilityProcessWorkerWorkbenchService {
 	 * Will fork a new process with the provided module identifier in a utility
 	 * process and establishes a message port connection to that process.
 	 *
-	 * Requires the forked process to be AMD module that uses our IPC channel framework
+	 * Requires the forked process to be ES module that uses our IPC channel framework
 	 * to respond to the provided `channelName` as a server.
 	 *
 	 * The process will be automatically terminated when the workbench window closes,

test/unit/assert-esm.js

@@ -1,498 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-
-// UTILITY
-
-// Object.create compatible in IE
-const create = Object.create || function (p) {
-	if (!p) { throw Error('no type'); }
-	function f() { }
-	f.prototype = p;
-	return new f();
-  };
-
-  // UTILITY
-  var util = {
-	inherits: function (ctor, superCtor) {
-	  ctor.super_ = superCtor;
-	  ctor.prototype = create(superCtor.prototype, {
-		constructor: {
-		  value: ctor,
-		  enumerable: false,
-		  writable: true,
-		  configurable: true
-		}
-	  });
-	},
-	isArray: function (ar) {
-	  return Array.isArray(ar);
-	},
-	isBoolean: function (arg) {
-	  return typeof arg === 'boolean';
-	},
-	isNull: function (arg) {
-	  return arg === null;
-	},
-	isNullOrUndefined: function (arg) {
-	  return arg == null;
-	},
-	isNumber: function (arg) {
-	  return typeof arg === 'number';
-	},
-	isString: function (arg) {
-	  return typeof arg === 'string';
-	},
-	isSymbol: function (arg) {
-	  return typeof arg === 'symbol';
-	},
-	isUndefined: function (arg) {
-	  return arg === undefined;
-	},
-	isRegExp: function (re) {
-	  return util.isObject(re) && util.objectToString(re) === '[object RegExp]';
-	},
-	isObject: function (arg) {
-	  return typeof arg === 'object' && arg !== null;
-	},
-	isDate: function (d) {
-	  return util.isObject(d) && util.objectToString(d) === '[object Date]';
-	},
-	isError: function (e) {
-	  return isObject(e) &&
-		(objectToString(e) === '[object Error]' || e instanceof Error);
-	},
-	isFunction: function (arg) {
-	  return typeof arg === 'function';
-	},
-	isPrimitive: function (arg) {
-	  return arg === null ||
-		typeof arg === 'boolean' ||
-		typeof arg === 'number' ||
-		typeof arg === 'string' ||
-		typeof arg === 'symbol' ||  // ES6 symbol
-		typeof arg === 'undefined';
-	},
-	objectToString: function (o) {
-	  return Object.prototype.toString.call(o);
-	}
-  };
-
-  const pSlice = Array.prototype.slice;
-
-  // From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys
-  const Object_keys = typeof Object.keys === 'function' ? Object.keys : (function () {
-	const hasOwnProperty = Object.prototype.hasOwnProperty,
-	  hasDontEnumBug = !({ toString: null }).propertyIsEnumerable('toString'),
-	  dontEnums = [
-		'toString',
-		'toLocaleString',
-		'valueOf',
-		'hasOwnProperty',
-		'isPrototypeOf',
-		'propertyIsEnumerable',
-		'constructor'
-	  ],
-	  dontEnumsLength = dontEnums.length;
-
-	return function (obj) {
-	  if (typeof obj !== 'object' && (typeof obj !== 'function' || obj === null)) {
-		throw new TypeError('Object.keys called on non-object');
-	  }
-
-	  let result = [], prop, i;
-
-	  for (prop in obj) {
-		if (hasOwnProperty.call(obj, prop)) {
-		  result.push(prop);
-		}
-	  }
-
-	  if (hasDontEnumBug) {
-		for (i = 0; i < dontEnumsLength; i++) {
-		  if (hasOwnProperty.call(obj, dontEnums[i])) {
-			result.push(dontEnums[i]);
-		  }
-		}
-	  }
-	  return result;
-	};
-  })();
-
-  // 1. The assert module provides functions that throw
-  // AssertionError's when particular conditions are not met. The
-  // assert module must conform to the following interface.
-
-  const assert = ok;
-
-  // 2. The AssertionError is defined in assert.
-  // new assert.AssertionError({ message: message,
-  //                             actual: actual,
-  //                             expected: expected })
-
-  assert.AssertionError = function AssertionError(options) {
-	this.name = 'AssertionError';
-	this.actual = options.actual;
-	this.expected = options.expected;
-	this.operator = options.operator;
-	if (options.message) {
-	  this.message = options.message;
-	  this.generatedMessage = false;
-	} else {
-	  this.message = getMessage(this);
-	  this.generatedMessage = true;
-	}
-	const stackStartFunction = options.stackStartFunction || fail;
-	if (Error.captureStackTrace) {
-	  Error.captureStackTrace(this, stackStartFunction);
-	} else {
-	  // try to throw an error now, and from the stack property
-	  // work out the line that called in to assert.js.
-	  try {
-		this.stack = (new Error).stack.toString();
-	  } catch (e) { }
-	}
-  };
-
-  // assert.AssertionError instanceof Error
-  util.inherits(assert.AssertionError, Error);
-
-  function replacer(key, value) {
-	if (util.isUndefined(value)) {
-	  return '' + value;
-	}
-	if (util.isNumber(value) && (isNaN(value) || !isFinite(value))) {
-	  return value.toString();
-	}
-	if (util.isFunction(value) || util.isRegExp(value)) {
-	  return value.toString();
-	}
-	return value;
-  }
-
-  function truncate(s, n) {
-	if (util.isString(s)) {
-	  return s.length < n ? s : s.slice(0, n);
-	} else {
-	  return s;
-	}
-  }
-
-  function getMessage(self) {
-	return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' +
-	  self.operator + ' ' +
-	  truncate(JSON.stringify(self.expected, replacer), 128);
-  }
-
-  // At present only the three keys mentioned above are used and
-  // understood by the spec. Implementations or sub modules can pass
-  // other keys to the AssertionError's constructor - they will be
-  // ignored.
-
-  // 3. All of the following functions must throw an AssertionError
-  // when a corresponding condition is not met, with a message that
-  // may be undefined if not provided.  All assertion methods provide
-  // both the actual and expected values to the assertion error for
-  // display purposes.
-
-  export function fail(actual, expected, message, operator, stackStartFunction) {
-	throw new assert.AssertionError({
-	  message: message,
-	  actual: actual,
-	  expected: expected,
-	  operator: operator,
-	  stackStartFunction: stackStartFunction
-	});
-  }
-
-  // EXTENSION! allows for well behaved errors defined elsewhere.
-  assert.fail = fail;
-
-  // 4. Pure assertion tests whether a value is truthy, as determined
-  // by !!guard.
-  // assert.ok(guard, message_opt);
-  // This statement is equivalent to assert.equal(true, !!guard,
-  // message_opt);. To test strictly for the value true, use
-  // assert.strictEqual(true, guard, message_opt);.
-
-  export function ok(value, message) {
-	if (!value) { fail(value, true, message, '==', assert.ok); }
-  }
-  assert.ok = ok;
-
-  // 5. The equality assertion tests shallow, coercive equality with
-  // ==.
-  // assert.equal(actual, expected, message_opt);
-
-  assert.equal = function equal(actual, expected, message) {
-	if (actual != expected) { fail(actual, expected, message, '==', assert.equal); }
-  };
-
-  // 6. The non-equality assertion tests for whether two objects are not equal
-  // with != assert.notEqual(actual, expected, message_opt);
-
-  assert.notEqual = function notEqual(actual, expected, message) {
-	if (actual == expected) {
-	  fail(actual, expected, message, '!=', assert.notEqual);
-	}
-  };
-
-  // 7. The equivalence assertion tests a deep equality relation.
-  // assert.deepEqual(actual, expected, message_opt);
-
-  assert.deepEqual = function deepEqual(actual, expected, message) {
-	if (!_deepEqual(actual, expected, false)) {
-	  fail(actual, expected, message, 'deepEqual', assert.deepEqual);
-	}
-  };
-
-  assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
-	if (!_deepEqual(actual, expected, true)) {
-	  fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);
-	}
-  };
-
-  function _deepEqual(actual, expected, strict) {
-	// 7.1. All identical values are equivalent, as determined by ===.
-	if (actual === expected) {
-	  return true;
-	  // } else if (actual instanceof Buffer && expected instanceof Buffer) {
-	  //   return compare(actual, expected) === 0;
-
-	  // 7.2. If the expected value is a Date object, the actual value is
-	  // equivalent if it is also a Date object that refers to the same time.
-	} else if (util.isDate(actual) && util.isDate(expected)) {
-	  return actual.getTime() === expected.getTime();
-
-	  // 7.3 If the expected value is a RegExp object, the actual value is
-	  // equivalent if it is also a RegExp object with the same source and
-	  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
-	} else if (util.isRegExp(actual) && util.isRegExp(expected)) {
-	  return actual.source === expected.source &&
-		actual.global === expected.global &&
-		actual.multiline === expected.multiline &&
-		actual.lastIndex === expected.lastIndex &&
-		actual.ignoreCase === expected.ignoreCase;
-
-	  // 7.4. Other pairs that do not both pass typeof value == 'object',
-	  // equivalence is determined by ==.
-	} else if ((actual === null || typeof actual !== 'object') &&
-	  (expected === null || typeof expected !== 'object')) {
-	  return strict ? actual === expected : actual == expected;
-
-	  // 7.5 For all other Object pairs, including Array objects, equivalence is
-	  // determined by having the same number of owned properties (as verified
-	  // with Object.prototype.hasOwnProperty.call), the same set of keys
-	  // (although not necessarily the same order), equivalent values for every
-	  // corresponding key, and an identical 'prototype' property. Note: this
-	  // accounts for both named and indexed properties on Arrays.
-	} else {
-	  return objEquiv(actual, expected, strict);
-	}
-  }
-
-  function isArguments(object) {
-	return Object.prototype.toString.call(object) == '[object Arguments]';
-  }
-
-  function objEquiv(a, b, strict) {
-	if (a === null || a === undefined || b === null || b === undefined) { return false; }
-	// if one is a primitive, the other must be same
-	if (util.isPrimitive(a) || util.isPrimitive(b)) { return a === b; }
-	if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) { return false; }
-	const aIsArgs = isArguments(a),
-	  bIsArgs = isArguments(b);
-	if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs)) { return false; }
-	if (aIsArgs) {
-	  a = pSlice.call(a);
-	  b = pSlice.call(b);
-	  return _deepEqual(a, b, strict);
-	}
-	let ka = Object.keys(a),
-	  kb = Object.keys(b),
-	  key, i;
-	// having the same number of owned properties (keys incorporates
-	// hasOwnProperty)
-	if (ka.length !== kb.length) { return false; }
-	//the same set of keys (although not necessarily the same order),
-	ka.sort();
-	kb.sort();
-	//~~~cheap key test
-	for (i = ka.length - 1; i >= 0; i--) {
-	  if (ka[i] !== kb[i]) { return false; }
-	}
-	//equivalent values for every corresponding key, and
-	//~~~possibly expensive deep test
-	for (i = ka.length - 1; i >= 0; i--) {
-	  key = ka[i];
-	  if (!_deepEqual(a[key], b[key], strict)) { return false; }
-	}
-	return true;
-  }
-
-  // 8. The non-equivalence assertion tests for any deep inequality.
-  // assert.notDeepEqual(actual, expected, message_opt);
-
-  assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
-	if (_deepEqual(actual, expected, false)) {
-	  fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
-	}
-  };
-
-  assert.notDeepStrictEqual = notDeepStrictEqual;
-  export function notDeepStrictEqual(actual, expected, message) {
-	if (_deepEqual(actual, expected, true)) {
-	  fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);
-	}
-  }
-
-
-  // 9. The strict equality assertion tests strict equality, as determined by ===.
-  // assert.strictEqual(actual, expected, message_opt);
-
-  assert.strictEqual = function strictEqual(actual, expected, message) {
-	if (actual !== expected) {
-	  fail(actual, expected, message, '===', assert.strictEqual);
-	}
-  };
-
-  // 10. The strict non-equality assertion tests for strict inequality, as
-  // determined by !==.  assert.notStrictEqual(actual, expected, message_opt);
-
-  assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
-	if (actual === expected) {
-	  fail(actual, expected, message, '!==', assert.notStrictEqual);
-	}
-  };
-
-  function expectedException(actual, expected) {
-	if (!actual || !expected) {
-	  return false;
-	}
-
-	if (Object.prototype.toString.call(expected) == '[object RegExp]') {
-	  return expected.test(actual);
-	} else if (actual instanceof expected) {
-	  return true;
-	} else if (expected.call({}, actual) === true) {
-	  return true;
-	}
-
-	return false;
-  }
-
-  function _throws(shouldThrow, block, expected, message) {
-	let actual;
-
-	if (typeof block !== 'function') {
-	  throw new TypeError('block must be a function');
-	}
-
-	if (typeof expected === 'string') {
-	  message = expected;
-	  expected = null;
-	}
-
-	try {
-	  block();
-	} catch (e) {
-	  actual = e;
-	}
-
-	message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
-	  (message ? ' ' + message : '.');
-
-	if (shouldThrow && !actual) {
-	  fail(actual, expected, 'Missing expected exception' + message);
-	}
-
-	if (!shouldThrow && expectedException(actual, expected)) {
-	  fail(actual, expected, 'Got unwanted exception' + message);
-	}
-
-	if ((shouldThrow && actual && expected &&
-	  !expectedException(actual, expected)) || (!shouldThrow && actual)) {
-	  throw actual;
-	}
-  }
-
-  // 11. Expected to throw an error:
-  // assert.throws(block, Error_opt, message_opt);
-
-  assert.throws = function (block, /*optional*/error, /*optional*/message) {
-	_throws.apply(this, [true].concat(pSlice.call(arguments)));
-  };
-
-  // EXTENSION! This is annoying to write outside this module.
-  assert.doesNotThrow = function (block, /*optional*/message) {
-	_throws.apply(this, [false].concat(pSlice.call(arguments)));
-  };
-
-  assert.ifError = function (err) { if (err) { throw err; } };
-
-  function checkIsPromise(obj) {
-	return (obj !== null && typeof obj === 'object' &&
-	  typeof obj.then === 'function' &&
-	  typeof obj.catch === 'function');
-  }
-
-  const NO_EXCEPTION_SENTINEL = {};
-  async function waitForActual(promiseFn) {
-	let resultPromise;
-	if (typeof promiseFn === 'function') {
-	  // Return a rejected promise if `promiseFn` throws synchronously.
-	  resultPromise = promiseFn();
-	  // Fail in case no promise is returned.
-	  if (!checkIsPromise(resultPromise)) {
-		throw new Error('ERR_INVALID_RETURN_VALUE: promiseFn did not return Promise. ' + resultPromise);
-	  }
-	} else if (checkIsPromise(promiseFn)) {
-	  resultPromise = promiseFn;
-	} else {
-	  throw new Error('ERR_INVALID_ARG_TYPE: promiseFn is not Function or Promise. ' + promiseFn);
-	}
-
-	try {
-	  await resultPromise;
-	} catch (e) {
-	  return e;
-	}
-	return NO_EXCEPTION_SENTINEL;
-  }
-
-  function expectsError(shouldHaveError, actual, message) {
-	if (shouldHaveError && actual === NO_EXCEPTION_SENTINEL) {
-	  fail(undefined, 'Error', `Missing expected rejection${message ? ': ' + message : ''}`)
-	} else if (!shouldHaveError && actual !== NO_EXCEPTION_SENTINEL) {
-	  fail(actual, undefined, `Got unexpected rejection (${actual.message})${message ? ': ' + message : ''}`)
-	}
-  }
-
-  assert.rejects = async function rejects(promiseFn, message) {
-	expectsError(true, await waitForActual(promiseFn), message);
-  };
-
-  assert.doesNotReject = async function doesNotReject(fn, message) {
-	expectsError(false, await waitForActual(fn), message);
-  };
-
-  // ESM export
-  export default assert;
-  export const AssertionError = assert.AssertionError
-  // export const fail = assert.fail
-  // export const ok = assert.ok
-  export const equal = assert.equal
-  export const notEqual = assert.notEqual
-  export const deepEqual = assert.deepEqual
-  export const deepStrictEqual = assert.deepStrictEqual
-  export const notDeepEqual = assert.notDeepEqual
-  // export const notDeepStrictEqual = assert.notDeepStrictEqual
-  export const strictEqual = assert.strictEqual
-  export const notStrictEqual = assert.notStrictEqual
-  export const throws = assert.throws
-  export const doesNotThrow = assert.doesNotThrow
-  export const ifError = assert.ifError
-  export const rejects = assert.rejects
-  export const doesNotReject = assert.doesNotReject

test/unit/assert.js

@@ -1,518 +1,498 @@
-// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
+/*---------------------------------------------------------------------------------------------
-//
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
-// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
-//
+ *--------------------------------------------------------------------------------------------*/
-// Copyright (c) 2011 Jxck
-//
-// Originally from node.js (http://nodejs.org)
-// Copyright Joyent, Inc.
-//
-// 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 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.
 
-(function(root, factory) {
-  if (typeof define === 'function' && define.amd) {
-    define([], factory); // AMD
-  } else if (typeof exports === 'object') {
-    module.exports = factory(); // CommonJS
-  } else {
-    root.assert = factory(); // Global
-  }
-})(this, function() {
 
 // UTILITY
 
 // Object.create compatible in IE
-var create = Object.create || function(p) {
+const create = Object.create || function (p) {
-  if (!p) throw Error('no type');
+	if (!p) { throw Error('no type'); }
-  function f() {};
+	function f() { }
-  f.prototype = p;
+	f.prototype = p;
-  return new f();
+	return new f();
-};
-
-// UTILITY
-var util = {
-  inherits: function(ctor, superCtor) {
-    ctor.super_ = superCtor;
-    ctor.prototype = create(superCtor.prototype, {
-      constructor: {
-        value: ctor,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
-  },
-  isArray: function(ar) {
-    return Array.isArray(ar);
-  },
-  isBoolean: function(arg) {
-    return typeof arg === 'boolean';
-  },
-  isNull: function(arg) {
-    return arg === null;
-  },
-  isNullOrUndefined: function(arg) {
-    return arg == null;
-  },
-  isNumber: function(arg) {
-    return typeof arg === 'number';
-  },
-  isString: function(arg) {
-    return typeof arg === 'string';
-  },
-  isSymbol: function(arg) {
-    return typeof arg === 'symbol';
-  },
-  isUndefined: function(arg) {
-    return arg === undefined;
-  },
-  isRegExp: function(re) {
-    return util.isObject(re) && util.objectToString(re) === '[object RegExp]';
-  },
-  isObject: function(arg) {
-    return typeof arg === 'object' && arg !== null;
-  },
-  isDate: function(d) {
-    return util.isObject(d) && util.objectToString(d) === '[object Date]';
-  },
-  isError: function(e) {
-    return isObject(e) &&
-      (objectToString(e) === '[object Error]' || e instanceof Error);
-  },
-  isFunction: function(arg) {
-    return typeof arg === 'function';
-  },
-  isPrimitive: function(arg) {
-    return arg === null ||
-      typeof arg === 'boolean' ||
-      typeof arg === 'number' ||
-      typeof arg === 'string' ||
-      typeof arg === 'symbol' ||  // ES6 symbol
-      typeof arg === 'undefined';
-  },
-  objectToString: function(o) {
-    return Object.prototype.toString.call(o);
-  }
-};
-
-var pSlice = Array.prototype.slice;
-
-// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys
-var Object_keys = typeof Object.keys === 'function' ? Object.keys : (function() {
-  var hasOwnProperty = Object.prototype.hasOwnProperty,
-      hasDontEnumBug = !({ toString: null }).propertyIsEnumerable('toString'),
-      dontEnums = [
-        'toString',
-        'toLocaleString',
-        'valueOf',
-        'hasOwnProperty',
-        'isPrototypeOf',
-        'propertyIsEnumerable',
-        'constructor'
-      ],
-      dontEnumsLength = dontEnums.length;
-
-  return function(obj) {
-    if (typeof obj !== 'object' && (typeof obj !== 'function' || obj === null)) {
-      throw new TypeError('Object.keys called on non-object');
-    }
-
-    var result = [], prop, i;
-
-    for (prop in obj) {
-      if (hasOwnProperty.call(obj, prop)) {
-        result.push(prop);
-      }
-    }
-
-    if (hasDontEnumBug) {
-      for (i = 0; i < dontEnumsLength; i++) {
-        if (hasOwnProperty.call(obj, dontEnums[i])) {
-          result.push(dontEnums[i]);
-        }
-      }
-    }
-    return result;
   };
-})();
 
-// 1. The assert module provides functions that throw
+  // UTILITY
-// AssertionError's when particular conditions are not met. The
+  var util = {
-// assert module must conform to the following interface.
+	inherits: function (ctor, superCtor) {
-
+	  ctor.super_ = superCtor;
-var assert = ok;
+	  ctor.prototype = create(superCtor.prototype, {
-
+		constructor: {
-// 2. The AssertionError is defined in assert.
+		  value: ctor,
-// new assert.AssertionError({ message: message,
+		  enumerable: false,
-//                             actual: actual,
+		  writable: true,
-//                             expected: expected })
+		  configurable: true
-
-assert.AssertionError = function AssertionError(options) {
-  this.name = 'AssertionError';
-  this.actual = options.actual;
-  this.expected = options.expected;
-  this.operator = options.operator;
-  if (options.message) {
-    this.message = options.message;
-    this.generatedMessage = false;
-  } else {
-    this.message = getMessage(this);
-    this.generatedMessage = true;
-  }
-  var stackStartFunction = options.stackStartFunction || fail;
-  if (Error.captureStackTrace) {
-    Error.captureStackTrace(this, stackStartFunction);
-  } else {
-    // try to throw an error now, and from the stack property
-    // work out the line that called in to assert.js.
-    try {
-      this.stack = (new Error).stack.toString();
-    } catch (e) {}
-  }
-};
-
-// assert.AssertionError instanceof Error
-util.inherits(assert.AssertionError, Error);
-
-function replacer(key, value) {
-  if (util.isUndefined(value)) {
-    return '' + value;
-  }
-  if (util.isNumber(value) && (isNaN(value) || !isFinite(value))) {
-    return value.toString();
-  }
-  if (util.isFunction(value) || util.isRegExp(value)) {
-    return value.toString();
-  }
-  return value;
-}
-
-function truncate(s, n) {
-  if (util.isString(s)) {
-    return s.length < n ? s : s.slice(0, n);
-  } else {
-    return s;
-  }
-}
-
-function getMessage(self) {
-  return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' +
-         self.operator + ' ' +
-         truncate(JSON.stringify(self.expected, replacer), 128);
-}
-
-// At present only the three keys mentioned above are used and
-// understood by the spec. Implementations or sub modules can pass
-// other keys to the AssertionError's constructor - they will be
-// ignored.
-
-// 3. All of the following functions must throw an AssertionError
-// when a corresponding condition is not met, with a message that
-// may be undefined if not provided.  All assertion methods provide
-// both the actual and expected values to the assertion error for
-// display purposes.
-
-function fail(actual, expected, message, operator, stackStartFunction) {
-  throw new assert.AssertionError({
-    message: message,
-    actual: actual,
-    expected: expected,
-    operator: operator,
-    stackStartFunction: stackStartFunction
-  });
-}
-
-// EXTENSION! allows for well behaved errors defined elsewhere.
-assert.fail = fail;
-
-// 4. Pure assertion tests whether a value is truthy, as determined
-// by !!guard.
-// assert.ok(guard, message_opt);
-// This statement is equivalent to assert.equal(true, !!guard,
-// message_opt);. To test strictly for the value true, use
-// assert.strictEqual(true, guard, message_opt);.
-
-function ok(value, message) {
-  if (!value) fail(value, true, message, '==', assert.ok);
-}
-assert.ok = ok;
-
-// 5. The equality assertion tests shallow, coercive equality with
-// ==.
-// assert.equal(actual, expected, message_opt);
-
-assert.equal = function equal(actual, expected, message) {
-  if (actual != expected) fail(actual, expected, message, '==', assert.equal);
-};
-
-// 6. The non-equality assertion tests for whether two objects are not equal
-// with != assert.notEqual(actual, expected, message_opt);
-
-assert.notEqual = function notEqual(actual, expected, message) {
-  if (actual == expected) {
-    fail(actual, expected, message, '!=', assert.notEqual);
-  }
-};
-
-// 7. The equivalence assertion tests a deep equality relation.
-// assert.deepEqual(actual, expected, message_opt);
-
-assert.deepEqual = function deepEqual(actual, expected, message) {
-  if (!_deepEqual(actual, expected, false)) {
-    fail(actual, expected, message, 'deepEqual', assert.deepEqual);
-  }
-};
-
-assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
-  if (!_deepEqual(actual, expected, true)) {
-    fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);
-  }
-};
-
-function _deepEqual(actual, expected, strict) {
-  // 7.1. All identical values are equivalent, as determined by ===.
-  if (actual === expected) {
-    return true;
-  // } else if (actual instanceof Buffer && expected instanceof Buffer) {
-  //   return compare(actual, expected) === 0;
-
-  // 7.2. If the expected value is a Date object, the actual value is
-  // equivalent if it is also a Date object that refers to the same time.
-  } else if (util.isDate(actual) && util.isDate(expected)) {
-    return actual.getTime() === expected.getTime();
-
-  // 7.3 If the expected value is a RegExp object, the actual value is
-  // equivalent if it is also a RegExp object with the same source and
-  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
-  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
-    return actual.source === expected.source &&
-           actual.global === expected.global &&
-           actual.multiline === expected.multiline &&
-           actual.lastIndex === expected.lastIndex &&
-           actual.ignoreCase === expected.ignoreCase;
-
-  // 7.4. Other pairs that do not both pass typeof value == 'object',
-  // equivalence is determined by ==.
-  } else if ((actual === null || typeof actual !== 'object') &&
-             (expected === null || typeof expected !== 'object')) {
-    return strict ? actual === expected : actual == expected;
-
-  // 7.5 For all other Object pairs, including Array objects, equivalence is
-  // determined by having the same number of owned properties (as verified
-  // with Object.prototype.hasOwnProperty.call), the same set of keys
-  // (although not necessarily the same order), equivalent values for every
-  // corresponding key, and an identical 'prototype' property. Note: this
-  // accounts for both named and indexed properties on Arrays.
-  } else {
-    return objEquiv(actual, expected, strict);
-  }
-}
-
-function isArguments(object) {
-  return Object.prototype.toString.call(object) == '[object Arguments]';
-}
-
-function objEquiv(a, b, strict) {
-  if (a === null || a === undefined || b === null || b === undefined)
-    return false;
-  // if one is a primitive, the other must be same
-  if (util.isPrimitive(a) || util.isPrimitive(b))
-    return a === b;
-  if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
-    return false;
-  var aIsArgs = isArguments(a),
-      bIsArgs = isArguments(b);
-  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
-    return false;
-  if (aIsArgs) {
-    a = pSlice.call(a);
-    b = pSlice.call(b);
-    return _deepEqual(a, b, strict);
-  }
-  var ka = Object.keys(a),
-      kb = Object.keys(b),
-      key, i;
-  // having the same number of owned properties (keys incorporates
-  // hasOwnProperty)
-  if (ka.length !== kb.length)
-    return false;
-  //the same set of keys (although not necessarily the same order),
-  ka.sort();
-  kb.sort();
-  //~~~cheap key test
-  for (i = ka.length - 1; i >= 0; i--) {
-    if (ka[i] !== kb[i])
-      return false;
-  }
-  //equivalent values for every corresponding key, and
-  //~~~possibly expensive deep test
-  for (i = ka.length - 1; i >= 0; i--) {
-    key = ka[i];
-    if (!_deepEqual(a[key], b[key], strict)) return false;
-  }
-  return true;
-}
-
-// 8. The non-equivalence assertion tests for any deep inequality.
-// assert.notDeepEqual(actual, expected, message_opt);
-
-assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
-  if (_deepEqual(actual, expected, false)) {
-    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
-  }
-};
-
-assert.notDeepStrictEqual = notDeepStrictEqual;
-function notDeepStrictEqual(actual, expected, message) {
-  if (_deepEqual(actual, expected, true)) {
-    fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);
-  }
-}
-
-
-// 9. The strict equality assertion tests strict equality, as determined by ===.
-// assert.strictEqual(actual, expected, message_opt);
-
-assert.strictEqual = function strictEqual(actual, expected, message) {
-  if (actual !== expected) {
-    fail(actual, expected, message, '===', assert.strictEqual);
-  }
-};
-
-// 10. The strict non-equality assertion tests for strict inequality, as
-// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);
-
-assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
-  if (actual === expected) {
-    fail(actual, expected, message, '!==', assert.notStrictEqual);
-  }
-};
-
-function expectedException(actual, expected) {
-  if (!actual || !expected) {
-    return false;
-  }
-
-  if (Object.prototype.toString.call(expected) == '[object RegExp]') {
-    return expected.test(actual);
-  } else if (actual instanceof expected) {
-    return true;
-  } else if (expected.call({}, actual) === true) {
-    return true;
-  }
-
-  return false;
-}
-
-function _throws(shouldThrow, block, expected, message) {
-  var actual;
-
-  if (typeof block !== 'function') {
-    throw new TypeError('block must be a function');
-  }
-
-  if (typeof expected === 'string') {
-    message = expected;
-    expected = null;
-  }
-
-  try {
-    block();
-  } catch (e) {
-    actual = e;
-  }
-
-  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
-            (message ? ' ' + message : '.');
-
-  if (shouldThrow && !actual) {
-    fail(actual, expected, 'Missing expected exception' + message);
-  }
-
-  if (!shouldThrow && expectedException(actual, expected)) {
-    fail(actual, expected, 'Got unwanted exception' + message);
-  }
-
-  if ((shouldThrow && actual && expected &&
-      !expectedException(actual, expected)) || (!shouldThrow && actual)) {
-    throw actual;
-  }
-}
-
-// 11. Expected to throw an error:
-// assert.throws(block, Error_opt, message_opt);
-
-assert.throws = function(block, /*optional*/error, /*optional*/message) {
-  _throws.apply(this, [true].concat(pSlice.call(arguments)));
-};
-
-// EXTENSION! This is annoying to write outside this module.
-assert.doesNotThrow = function(block, /*optional*/message) {
-  _throws.apply(this, [false].concat(pSlice.call(arguments)));
-};
-
-assert.ifError = function(err) { if (err) {throw err;}};
-
-function checkIsPromise(obj) {
-	return (obj !== null && typeof obj === 'object' &&
-		typeof obj.then === 'function' &&
-		typeof obj.catch === 'function');
-}
-
-const NO_EXCEPTION_SENTINEL = {};
-async function waitForActual(promiseFn) {
-	let resultPromise;
-	if (typeof promiseFn === 'function') {
-		// Return a rejected promise if `promiseFn` throws synchronously.
-		resultPromise = promiseFn();
-		// Fail in case no promise is returned.
-		if (!checkIsPromise(resultPromise)) {
-			throw new Error('ERR_INVALID_RETURN_VALUE: promiseFn did not return Promise. ' + resultPromise);
 		}
-	} else if (checkIsPromise(promiseFn)) {
+	  });
-		resultPromise = promiseFn;
+	},
+	isArray: function (ar) {
+	  return Array.isArray(ar);
+	},
+	isBoolean: function (arg) {
+	  return typeof arg === 'boolean';
+	},
+	isNull: function (arg) {
+	  return arg === null;
+	},
+	isNullOrUndefined: function (arg) {
+	  return arg == null;
+	},
+	isNumber: function (arg) {
+	  return typeof arg === 'number';
+	},
+	isString: function (arg) {
+	  return typeof arg === 'string';
+	},
+	isSymbol: function (arg) {
+	  return typeof arg === 'symbol';
+	},
+	isUndefined: function (arg) {
+	  return arg === undefined;
+	},
+	isRegExp: function (re) {
+	  return util.isObject(re) && util.objectToString(re) === '[object RegExp]';
+	},
+	isObject: function (arg) {
+	  return typeof arg === 'object' && arg !== null;
+	},
+	isDate: function (d) {
+	  return util.isObject(d) && util.objectToString(d) === '[object Date]';
+	},
+	isError: function (e) {
+	  return isObject(e) &&
+		(objectToString(e) === '[object Error]' || e instanceof Error);
+	},
+	isFunction: function (arg) {
+	  return typeof arg === 'function';
+	},
+	isPrimitive: function (arg) {
+	  return arg === null ||
+		typeof arg === 'boolean' ||
+		typeof arg === 'number' ||
+		typeof arg === 'string' ||
+		typeof arg === 'symbol' ||  // ES6 symbol
+		typeof arg === 'undefined';
+	},
+	objectToString: function (o) {
+	  return Object.prototype.toString.call(o);
+	}
+  };
+
+  const pSlice = Array.prototype.slice;
+
+  // From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys
+  const Object_keys = typeof Object.keys === 'function' ? Object.keys : (function () {
+	const hasOwnProperty = Object.prototype.hasOwnProperty,
+	  hasDontEnumBug = !({ toString: null }).propertyIsEnumerable('toString'),
+	  dontEnums = [
+		'toString',
+		'toLocaleString',
+		'valueOf',
+		'hasOwnProperty',
+		'isPrototypeOf',
+		'propertyIsEnumerable',
+		'constructor'
+	  ],
+	  dontEnumsLength = dontEnums.length;
+
+	return function (obj) {
+	  if (typeof obj !== 'object' && (typeof obj !== 'function' || obj === null)) {
+		throw new TypeError('Object.keys called on non-object');
+	  }
+
+	  let result = [], prop, i;
+
+	  for (prop in obj) {
+		if (hasOwnProperty.call(obj, prop)) {
+		  result.push(prop);
+		}
+	  }
+
+	  if (hasDontEnumBug) {
+		for (i = 0; i < dontEnumsLength; i++) {
+		  if (hasOwnProperty.call(obj, dontEnums[i])) {
+			result.push(dontEnums[i]);
+		  }
+		}
+	  }
+	  return result;
+	};
+  })();
+
+  // 1. The assert module provides functions that throw
+  // AssertionError's when particular conditions are not met. The
+  // assert module must conform to the following interface.
+
+  const assert = ok;
+
+  // 2. The AssertionError is defined in assert.
+  // new assert.AssertionError({ message: message,
+  //                             actual: actual,
+  //                             expected: expected })
+
+  assert.AssertionError = function AssertionError(options) {
+	this.name = 'AssertionError';
+	this.actual = options.actual;
+	this.expected = options.expected;
+	this.operator = options.operator;
+	if (options.message) {
+	  this.message = options.message;
+	  this.generatedMessage = false;
 	} else {
-		throw new Error('ERR_INVALID_ARG_TYPE: promiseFn is not Function or Promise. ' + promiseFn);
+	  this.message = getMessage(this);
+	  this.generatedMessage = true;
+	}
+	const stackStartFunction = options.stackStartFunction || fail;
+	if (Error.captureStackTrace) {
+	  Error.captureStackTrace(this, stackStartFunction);
+	} else {
+	  // try to throw an error now, and from the stack property
+	  // work out the line that called in to assert.js.
+	  try {
+		this.stack = (new Error).stack.toString();
+	  } catch (e) { }
+	}
+  };
+
+  // assert.AssertionError instanceof Error
+  util.inherits(assert.AssertionError, Error);
+
+  function replacer(key, value) {
+	if (util.isUndefined(value)) {
+	  return '' + value;
+	}
+	if (util.isNumber(value) && (isNaN(value) || !isFinite(value))) {
+	  return value.toString();
+	}
+	if (util.isFunction(value) || util.isRegExp(value)) {
+	  return value.toString();
+	}
+	return value;
+  }
+
+  function truncate(s, n) {
+	if (util.isString(s)) {
+	  return s.length < n ? s : s.slice(0, n);
+	} else {
+	  return s;
+	}
+  }
+
+  function getMessage(self) {
+	return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' +
+	  self.operator + ' ' +
+	  truncate(JSON.stringify(self.expected, replacer), 128);
+  }
+
+  // At present only the three keys mentioned above are used and
+  // understood by the spec. Implementations or sub modules can pass
+  // other keys to the AssertionError's constructor - they will be
+  // ignored.
+
+  // 3. All of the following functions must throw an AssertionError
+  // when a corresponding condition is not met, with a message that
+  // may be undefined if not provided.  All assertion methods provide
+  // both the actual and expected values to the assertion error for
+  // display purposes.
+
+  export function fail(actual, expected, message, operator, stackStartFunction) {
+	throw new assert.AssertionError({
+	  message: message,
+	  actual: actual,
+	  expected: expected,
+	  operator: operator,
+	  stackStartFunction: stackStartFunction
+	});
+  }
+
+  // EXTENSION! allows for well behaved errors defined elsewhere.
+  assert.fail = fail;
+
+  // 4. Pure assertion tests whether a value is truthy, as determined
+  // by !!guard.
+  // assert.ok(guard, message_opt);
+  // This statement is equivalent to assert.equal(true, !!guard,
+  // message_opt);. To test strictly for the value true, use
+  // assert.strictEqual(true, guard, message_opt);.
+
+  export function ok(value, message) {
+	if (!value) { fail(value, true, message, '==', assert.ok); }
+  }
+  assert.ok = ok;
+
+  // 5. The equality assertion tests shallow, coercive equality with
+  // ==.
+  // assert.equal(actual, expected, message_opt);
+
+  assert.equal = function equal(actual, expected, message) {
+	if (actual != expected) { fail(actual, expected, message, '==', assert.equal); }
+  };
+
+  // 6. The non-equality assertion tests for whether two objects are not equal
+  // with != assert.notEqual(actual, expected, message_opt);
+
+  assert.notEqual = function notEqual(actual, expected, message) {
+	if (actual == expected) {
+	  fail(actual, expected, message, '!=', assert.notEqual);
+	}
+  };
+
+  // 7. The equivalence assertion tests a deep equality relation.
+  // assert.deepEqual(actual, expected, message_opt);
+
+  assert.deepEqual = function deepEqual(actual, expected, message) {
+	if (!_deepEqual(actual, expected, false)) {
+	  fail(actual, expected, message, 'deepEqual', assert.deepEqual);
+	}
+  };
+
+  assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
+	if (!_deepEqual(actual, expected, true)) {
+	  fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);
+	}
+  };
+
+  function _deepEqual(actual, expected, strict) {
+	// 7.1. All identical values are equivalent, as determined by ===.
+	if (actual === expected) {
+	  return true;
+	  // } else if (actual instanceof Buffer && expected instanceof Buffer) {
+	  //   return compare(actual, expected) === 0;
+
+	  // 7.2. If the expected value is a Date object, the actual value is
+	  // equivalent if it is also a Date object that refers to the same time.
+	} else if (util.isDate(actual) && util.isDate(expected)) {
+	  return actual.getTime() === expected.getTime();
+
+	  // 7.3 If the expected value is a RegExp object, the actual value is
+	  // equivalent if it is also a RegExp object with the same source and
+	  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
+	} else if (util.isRegExp(actual) && util.isRegExp(expected)) {
+	  return actual.source === expected.source &&
+		actual.global === expected.global &&
+		actual.multiline === expected.multiline &&
+		actual.lastIndex === expected.lastIndex &&
+		actual.ignoreCase === expected.ignoreCase;
+
+	  // 7.4. Other pairs that do not both pass typeof value == 'object',
+	  // equivalence is determined by ==.
+	} else if ((actual === null || typeof actual !== 'object') &&
+	  (expected === null || typeof expected !== 'object')) {
+	  return strict ? actual === expected : actual == expected;
+
+	  // 7.5 For all other Object pairs, including Array objects, equivalence is
+	  // determined by having the same number of owned properties (as verified
+	  // with Object.prototype.hasOwnProperty.call), the same set of keys
+	  // (although not necessarily the same order), equivalent values for every
+	  // corresponding key, and an identical 'prototype' property. Note: this
+	  // accounts for both named and indexed properties on Arrays.
+	} else {
+	  return objEquiv(actual, expected, strict);
+	}
+  }
+
+  function isArguments(object) {
+	return Object.prototype.toString.call(object) == '[object Arguments]';
+  }
+
+  function objEquiv(a, b, strict) {
+	if (a === null || a === undefined || b === null || b === undefined) { return false; }
+	// if one is a primitive, the other must be same
+	if (util.isPrimitive(a) || util.isPrimitive(b)) { return a === b; }
+	if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) { return false; }
+	const aIsArgs = isArguments(a),
+	  bIsArgs = isArguments(b);
+	if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs)) { return false; }
+	if (aIsArgs) {
+	  a = pSlice.call(a);
+	  b = pSlice.call(b);
+	  return _deepEqual(a, b, strict);
+	}
+	let ka = Object.keys(a),
+	  kb = Object.keys(b),
+	  key, i;
+	// having the same number of owned properties (keys incorporates
+	// hasOwnProperty)
+	if (ka.length !== kb.length) { return false; }
+	//the same set of keys (although not necessarily the same order),
+	ka.sort();
+	kb.sort();
+	//~~~cheap key test
+	for (i = ka.length - 1; i >= 0; i--) {
+	  if (ka[i] !== kb[i]) { return false; }
+	}
+	//equivalent values for every corresponding key, and
+	//~~~possibly expensive deep test
+	for (i = ka.length - 1; i >= 0; i--) {
+	  key = ka[i];
+	  if (!_deepEqual(a[key], b[key], strict)) { return false; }
+	}
+	return true;
+  }
+
+  // 8. The non-equivalence assertion tests for any deep inequality.
+  // assert.notDeepEqual(actual, expected, message_opt);
+
+  assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+	if (_deepEqual(actual, expected, false)) {
+	  fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
+	}
+  };
+
+  assert.notDeepStrictEqual = notDeepStrictEqual;
+  export function notDeepStrictEqual(actual, expected, message) {
+	if (_deepEqual(actual, expected, true)) {
+	  fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);
+	}
+  }
+
+
+  // 9. The strict equality assertion tests strict equality, as determined by ===.
+  // assert.strictEqual(actual, expected, message_opt);
+
+  assert.strictEqual = function strictEqual(actual, expected, message) {
+	if (actual !== expected) {
+	  fail(actual, expected, message, '===', assert.strictEqual);
+	}
+  };
+
+  // 10. The strict non-equality assertion tests for strict inequality, as
+  // determined by !==.  assert.notStrictEqual(actual, expected, message_opt);
+
+  assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+	if (actual === expected) {
+	  fail(actual, expected, message, '!==', assert.notStrictEqual);
+	}
+  };
+
+  function expectedException(actual, expected) {
+	if (!actual || !expected) {
+	  return false;
+	}
+
+	if (Object.prototype.toString.call(expected) == '[object RegExp]') {
+	  return expected.test(actual);
+	} else if (actual instanceof expected) {
+	  return true;
+	} else if (expected.call({}, actual) === true) {
+	  return true;
+	}
+
+	return false;
+  }
+
+  function _throws(shouldThrow, block, expected, message) {
+	let actual;
+
+	if (typeof block !== 'function') {
+	  throw new TypeError('block must be a function');
+	}
+
+	if (typeof expected === 'string') {
+	  message = expected;
+	  expected = null;
 	}
 
 	try {
-		await resultPromise;
+	  block();
 	} catch (e) {
-		return e;
+	  actual = e;
+	}
+
+	message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
+	  (message ? ' ' + message : '.');
+
+	if (shouldThrow && !actual) {
+	  fail(actual, expected, 'Missing expected exception' + message);
+	}
+
+	if (!shouldThrow && expectedException(actual, expected)) {
+	  fail(actual, expected, 'Got unwanted exception' + message);
+	}
+
+	if ((shouldThrow && actual && expected &&
+	  !expectedException(actual, expected)) || (!shouldThrow && actual)) {
+	  throw actual;
+	}
+  }
+
+  // 11. Expected to throw an error:
+  // assert.throws(block, Error_opt, message_opt);
+
+  assert.throws = function (block, /*optional*/error, /*optional*/message) {
+	_throws.apply(this, [true].concat(pSlice.call(arguments)));
+  };
+
+  // EXTENSION! This is annoying to write outside this module.
+  assert.doesNotThrow = function (block, /*optional*/message) {
+	_throws.apply(this, [false].concat(pSlice.call(arguments)));
+  };
+
+  assert.ifError = function (err) { if (err) { throw err; } };
+
+  function checkIsPromise(obj) {
+	return (obj !== null && typeof obj === 'object' &&
+	  typeof obj.then === 'function' &&
+	  typeof obj.catch === 'function');
+  }
+
+  const NO_EXCEPTION_SENTINEL = {};
+  async function waitForActual(promiseFn) {
+	let resultPromise;
+	if (typeof promiseFn === 'function') {
+	  // Return a rejected promise if `promiseFn` throws synchronously.
+	  resultPromise = promiseFn();
+	  // Fail in case no promise is returned.
+	  if (!checkIsPromise(resultPromise)) {
+		throw new Error('ERR_INVALID_RETURN_VALUE: promiseFn did not return Promise. ' + resultPromise);
+	  }
+	} else if (checkIsPromise(promiseFn)) {
+	  resultPromise = promiseFn;
+	} else {
+	  throw new Error('ERR_INVALID_ARG_TYPE: promiseFn is not Function or Promise. ' + promiseFn);
+	}
+
+	try {
+	  await resultPromise;
+	} catch (e) {
+	  return e;
 	}
 	return NO_EXCEPTION_SENTINEL;
-}
+  }
 
-function expectsError(shouldHaveError, actual, message) {
+  function expectsError(shouldHaveError, actual, message) {
 	if (shouldHaveError && actual === NO_EXCEPTION_SENTINEL) {
-		fail(undefined, 'Error', `Missing expected rejection${message ? ': ' + message : ''}`)
+	  fail(undefined, 'Error', `Missing expected rejection${message ? ': ' + message : ''}`)
 	} else if (!shouldHaveError && actual !== NO_EXCEPTION_SENTINEL) {
-		fail(actual, undefined, `Got unexpected rejection (${actual.message})${message ? ': ' + message : ''}`)
+	  fail(actual, undefined, `Got unexpected rejection (${actual.message})${message ? ': ' + message : ''}`)
 	}
-}
+  }
 
-assert.rejects = async function rejects(promiseFn, message) {
+  assert.rejects = async function rejects(promiseFn, message) {
 	expectsError(true, await waitForActual(promiseFn), message);
-};
+  };
 
-assert.doesNotReject = async function doesNotReject(fn, message) {
+  assert.doesNotReject = async function doesNotReject(fn, message) {
 	expectsError(false, await waitForActual(fn), message);
-};
+  };
 
-return assert;
+  // ESM export
-});
+  export default assert;
+  export const AssertionError = assert.AssertionError
+  // export const fail = assert.fail
+  // export const ok = assert.ok
+  export const equal = assert.equal
+  export const notEqual = assert.notEqual
+  export const deepEqual = assert.deepEqual
+  export const deepStrictEqual = assert.deepStrictEqual
+  export const notDeepEqual = assert.notDeepEqual
+  // export const notDeepStrictEqual = assert.notDeepStrictEqual
+  export const strictEqual = assert.strictEqual
+  export const notStrictEqual = assert.notStrictEqual
+  export const throws = assert.throws
+  export const doesNotThrow = assert.doesNotThrow
+  export const ifError = assert.ifError
+  export const rejects = assert.rejects
+  export const doesNotReject = assert.doesNotReject

test/unit/browser/renderer.html

@@ -53,7 +53,7 @@
 		const importMap = {
 			imports: {
 				vs: new URL(`../../../${out}/vs`, baseUrl).href,
-				assert: new URL('../assert-esm.js', baseUrl).href,
+				assert: new URL('../assert.js', baseUrl).href,
 				sinon: new URL('../../../node_modules/sinon/pkg/sinon-esm.js', baseUrl).href,
 				'sinon-test': new URL('../../../node_modules/sinon-test/dist/sinon-test-es.js', baseUrl).href,
 				'@xterm/xterm': new URL('../../../node_modules/@xterm/xterm/lib/xterm.js', baseUrl).href,

test/unit/electron/renderer.html

@@ -78,7 +78,7 @@
 		// generate import map
 		const importMap = {
 			imports: {
-				assert: new URL('../test/unit/assert-esm.js', baseUrl).href,
+				assert: new URL('../test/unit/assert.js', baseUrl).href,
 				sinon: new URL('../node_modules/sinon/pkg/sinon-esm.js', baseUrl).href,
 				'sinon-test': new URL('../node_modules/sinon-test/dist/sinon-test-es.js', baseUrl).href,
 				'electron': asRequireBlobUri('electron'),