@capsule-run/sdk 0.8.3 → 0.8.5

package/dist/polyfills/unenv-runtime/node/assert.mjs

@@ -0,0 +1,737 @@
+import { notImplemented, notImplementedClass } from "../_internal/utils.mjs";
+// TODO: Implement Error classes
+const ERR_AMBIGUOUS_ARGUMENT = Error;
+const ERR_INVALID_ARG_TYPE = Error;
+const ERR_INVALID_ARG_VALUE = Error;
+const ERR_INVALID_RETURN_VALUE = Error;
+const ERR_MISSING_ARGS = Error;
+export class AssertionError extends Error {
+	actual;
+	expected;
+	operator;
+	generatedMessage;
+	code = "ERR_ASSERTION";
+	constructor(options) {
+		super();
+		this.actual = options.actual;
+		this.expected = options.expected;
+		this.operator = options.operator || "";
+		this.generatedMessage = options.message === undefined;
+		const stackStartFn = options.stackStartFn || fail;
+		Error.captureStackTrace?.(this, stackStartFn);
+	}
+}
+const inspect = (val, opts) => val;
+const isEqual = (a, b) => a === b || JSON.stringify(a) === JSON.stringify(b);
+const isDeepEqual = isEqual;
+const isDeepStrictEqual = isEqual;
+let warned = false;
+// 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 NO_EXCEPTION_SENTINEL = {};
+// 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.
+// ----------------------------------------------------------------------------
+// Assertions
+// ----------------------------------------------------------------------------
+/**
+* Pure assertion tests whether a value is truthy, as determined
+* by !!value.
+* @param {...any} args
+* @returns {void}
+*/
+export function ok(...args) {
+	// @ts-expect-error
+	innerOk(ok, args.length, ...args);
+}
+/**
+* The equality assertion tests shallow, coercive equality with ==.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function equal(actual, expected, message) {
+	if (arguments.length < 2) {
+		// @ts-expect-error
+		throw new ERR_MISSING_ARGS("actual", "expected");
+	}
+	if (actual != expected && (!Number.isNaN(actual) || !Number.isNaN(expected))) {
+		innerFail({
+			actual,
+			expected,
+			message,
+			operator: "==",
+			stackStartFn: equal
+		});
+	}
+}
+/**
+* The non-equality assertion tests for whether two objects are not
+* equal with !=.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function notEqual(actual, expected, message) {
+	if (arguments.length < 2) {
+		// @ts-expect-error
+		throw new ERR_MISSING_ARGS("actual", "expected");
+	}
+	if (actual == expected || Number.isNaN(actual) && Number.isNaN(expected)) {
+		innerFail({
+			actual,
+			expected,
+			message,
+			operator: "!=",
+			stackStartFn: notEqual
+		});
+	}
+}
+/**
+* The deep equivalence assertion tests a deep equality relation.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function deepEqual(actual, expected, message) {
+	if (arguments.length < 2) {
+		// @ts-expect-error
+		throw new ERR_MISSING_ARGS("actual", "expected");
+	}
+	if (!isDeepEqual(actual, expected)) {
+		innerFail({
+			actual,
+			expected,
+			message,
+			operator: "deepEqual",
+			stackStartFn: deepEqual
+		});
+	}
+}
+/**
+* The deep non-equivalence assertion tests for any deep inequality.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function notDeepEqual(actual, expected, message) {
+	if (arguments.length < 2) {
+		// @ts-expect-error
+		throw new ERR_MISSING_ARGS("actual", "expected");
+	}
+	if (isDeepEqual(actual, expected)) {
+		innerFail({
+			actual,
+			expected,
+			message,
+			operator: "notDeepEqual",
+			stackStartFn: notDeepEqual
+		});
+	}
+}
+/**
+* The deep strict equivalence assertion tests a deep strict equality
+* relation.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function deepStrictEqual(actual, expected, message) {
+	if (arguments.length < 2) {
+		// @ts-expect-error
+		throw new ERR_MISSING_ARGS("actual", "expected");
+	}
+	if (!isDeepStrictEqual(actual, expected)) {
+		innerFail({
+			actual,
+			expected,
+			message,
+			operator: "deepStrictEqual",
+			stackStartFn: deepStrictEqual
+		});
+	}
+}
+/**
+* The deep strict non-equivalence assertion tests for any deep strict
+* inequality.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function notDeepStrictEqual(actual, expected, message) {
+	if (arguments.length < 2) {
+		// @ts-expect-error
+		throw new ERR_MISSING_ARGS("actual", "expected");
+	}
+	if (isDeepStrictEqual(actual, expected)) {
+		innerFail({
+			actual,
+			expected,
+			message,
+			operator: "notDeepStrictEqual",
+			stackStartFn: notDeepStrictEqual
+		});
+	}
+}
+/**
+* The strict equivalence assertion tests a strict equality relation.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function strictEqual(actual, expected, message) {
+	if (arguments.length < 2) {
+		// @ts-expect-error
+		throw new ERR_MISSING_ARGS("actual", "expected");
+	}
+	if (!Object.is(actual, expected)) {
+		innerFail({
+			actual,
+			expected,
+			message,
+			operator: "strictEqual",
+			stackStartFn: strictEqual
+		});
+	}
+}
+/**
+* The strict non-equivalence assertion tests for any strict inequality.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function notStrictEqual(actual, expected, message) {
+	if (arguments.length < 2) {
+		// @ts-expect-error
+		throw new ERR_MISSING_ARGS("actual", "expected");
+	}
+	if (Object.is(actual, expected)) {
+		innerFail({
+			actual,
+			expected,
+			message,
+			operator: "notStrictEqual",
+			stackStartFn: notStrictEqual
+		});
+	}
+}
+/**
+* Expects the function `promiseFn` to throw an error.
+*/
+export function throws(promiseFn, ...args) {
+	// @ts-expect-error
+	expectsError(throws, getActual(promiseFn), ...args);
+}
+/**
+* Expects `promiseFn` function or its value to reject.
+*/
+export async function rejects(promiseFn, ...args) {
+	// @ts-expect-error
+	expectsError(rejects, await waitForActual(promiseFn), ...args);
+}
+/**
+* Asserts that the function `fn` does not throw an error.
+*/
+export function doesNotThrow(fn, ...args) {
+	// @ts-expect-error
+	expectsNoError(doesNotThrow, getActual(fn), ...args);
+}
+/**
+* Expects `fn` or its value to not reject.
+*/
+export async function doesNotReject(fn, ...args) {
+	// @ts-expect-error
+	expectsNoError(doesNotReject, await waitForActual(fn), ...args);
+}
+/**
+* Throws `value` if the value is not `null` or `undefined`.
+* @param {any} err
+* @returns {void}
+*/
+export function ifError(err) {
+	if (err !== null && err !== undefined) {
+		let message = "ifError got unwanted exception: ";
+		if (typeof err === "object" && typeof err.message === "string") {
+			if (err.message.length === 0 && err.constructor) {
+				message += err.constructor.name;
+			} else {
+				message += err.message;
+			}
+		} else {
+			message += inspect(err);
+		}
+		const newErr = new AssertionError({
+			actual: err,
+			expected: null,
+			operator: "ifError",
+			message,
+			stackStartFn: ifError
+		});
+		// Make sure we actually have a stack trace!
+		const origStack = err?.stack;
+		if (typeof origStack === "string") {
+			// This will remove any duplicated frames from the error frames taken
+			// from within `ifError` and add the original error frames to the newly
+			// created ones.
+			const origStackStart = origStack.indexOf("\n    at");
+			if (origStackStart !== -1) {
+				const originalFrames = origStack.slice(origStackStart + 1).split("\n");
+				// Filter all frames existing in err.stack.
+				let newFrames = (newErr.stack || "").split("\n");
+				for (const errFrame of originalFrames) {
+					// Find the first occurrence of the frame.
+					const pos = newFrames.indexOf(errFrame);
+					if (pos !== -1) {
+						// Only keep new frames.
+						newFrames = newFrames.slice(0, pos);
+						break;
+					}
+				}
+				const stackStart = newFrames.join("\n");
+				const stackEnd = originalFrames.join("\n");
+				newErr.stack = `${stackStart}\n${stackEnd}`;
+			}
+		}
+		throw newErr;
+	}
+}
+/**
+* Expects the `string` input to match the regular expression.
+* @param {string} string
+* @param {RegExp} regexp
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function match(string, regexp, message) {
+	internalMatch(string, regexp, message, match);
+}
+/**
+* Expects the `string` input not to match the regular expression.
+* @param {string} string
+* @param {RegExp} regexp
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function doesNotMatch(string, regexp, message) {
+	internalMatch(string, regexp, message, doesNotMatch);
+}
+export function fail(actual, expected, message, operator, stackStartFn) {
+	const argsLen = arguments.length;
+	let internalMessage = false;
+	if (actual == null && argsLen <= 1) {
+		internalMessage = true;
+		message = "Failed";
+	} else if (argsLen === 1) {
+		message = actual;
+		actual = undefined;
+	} else {
+		if (warned === false) {
+			warned = true;
+			process.emitWarning("assert.fail() with more than one argument is deprecated. " + "Please use assert.strictEqual() instead or only pass a message.", "DeprecationWarning", "DEP0094");
+		}
+		if (argsLen === 2) operator = "!=";
+	}
+	if (message instanceof Error) throw message;
+	const errArgs = {
+		actual,
+		expected,
+		operator: operator === undefined ? "fail" : operator,
+		stackStartFn: stackStartFn || fail,
+		message
+	};
+	const err = new AssertionError(errArgs);
+	if (internalMessage) {
+		err.generatedMessage = true;
+	}
+	throw err;
+}
+// ----------------------------------------------------------------------------
+// Internal utils
+// ----------------------------------------------------------------------------
+function innerFail(obj) {
+	if (obj.message instanceof Error) throw obj.message;
+	throw new AssertionError(obj);
+}
+function innerOk(fn, argLen, value, message) {
+	if (!value) {
+		let generatedMessage = false;
+		if (argLen === 0) {
+			generatedMessage = true;
+			message = "No value argument passed to `assert.ok()`";
+		} else if (message == null) {
+			generatedMessage = true;
+			message = "<null>";
+		} else if (message instanceof Error) {
+			throw message;
+		}
+		const err = new AssertionError({
+			actual: value,
+			expected: true,
+			message,
+			operator: "==",
+			stackStartFn: fn
+		});
+		err.generatedMessage = generatedMessage;
+		throw err;
+	}
+}
+class Comparison {
+	constructor(obj, keys, actual) {
+		for (const key of keys) {
+			if (key in obj) {
+				if (actual !== undefined && typeof actual[key] === "string" && obj[key] instanceof RegExp && obj[key].exec(actual[key]) !== null) {
+					// @ts-expect-error
+					this[key] = actual[key];
+				} else {
+					// @ts-expect-error
+					this[key] = obj[key];
+				}
+			}
+		}
+	}
+}
+function compareExceptionKey(actual, expected, key, message, keys, fn) {
+	if (!(key in actual) || !isDeepStrictEqual(actual[key], expected[key])) {
+		if (!message) {
+			// Create placeholder objects to create a nice output.
+			const a = new Comparison(actual, keys);
+			const b = new Comparison(expected, keys, actual);
+			const err = new AssertionError({
+				actual: a,
+				expected: b,
+				operator: "deepStrictEqual",
+				stackStartFn: fn
+			});
+			err.actual = actual;
+			err.expected = expected;
+			err.operator = fn.name;
+			throw err;
+		}
+		innerFail({
+			actual,
+			expected,
+			message,
+			operator: fn.name,
+			stackStartFn: fn
+		});
+	}
+}
+function expectedException(actual, expected, message, fn) {
+	let generatedMessage = false;
+	let throwError = false;
+	if (typeof expected !== "function") {
+		// Handle regular expressions.
+		if (expected instanceof RegExp) {
+			const str = String(actual);
+			if (RegExp.prototype.exec.call(expected, str) !== null) return;
+			if (!message) {
+				generatedMessage = true;
+				message = "The input did not match the regular expression " + `${inspect(expected)}. Input:\n\n${inspect(str)}\n`;
+			}
+			throwError = true;
+		} else if (typeof actual !== "object" || actual === null) {
+			const err = new AssertionError({
+				actual,
+				expected,
+				message,
+				operator: "deepStrictEqual",
+				stackStartFn: fn
+			});
+			err.operator = fn.name;
+			throw err;
+		} else {
+			// Handle validation objects.
+			const keys = Object.keys(expected);
+			// Special handle errors to make sure the name and the message are
+			// compared as well.
+			if (expected instanceof Error) {
+				keys.push("name", "message");
+			} else if (keys.length === 0) {
+				throw new ERR_INVALID_ARG_VALUE(
+					"error",
+					expected,
+					// @ts-expect-error
+					"may not be an empty object"
+				);
+			}
+			for (const key of keys) {
+				if (typeof actual[key] === "string" && expected[key] instanceof RegExp && expected[key].exec(actual[key]) !== null) {
+					continue;
+				}
+				compareExceptionKey(actual, expected, key, message, keys, fn);
+			}
+			return;
+		}
+	} else if (expected.prototype !== undefined && actual instanceof expected) {
+		return;
+	} else if (expected instanceof Error) {
+		if (!message) {
+			generatedMessage = true;
+			message = "The error is expected to be an instance of " + `"${expected.name}". Received `;
+			if (actual instanceof Error) {
+				const name = actual.constructor && actual.constructor.name || actual.name;
+				if (expected.name === name) {
+					message += "an error with identical name but a different prototype.";
+				} else {
+					message += `"${name}"`;
+				}
+				if (actual.message) {
+					message += `\n\nError message:\n\n${actual.message}`;
+				}
+			} else {
+				message += `"${inspect(actual, { depth: -1 })}"`;
+			}
+		}
+		throwError = true;
+	} else {
+		// Check validation functions return value.
+		const res = Reflect.apply(expected, {}, [actual]);
+		if (res !== true) {
+			if (!message) {
+				generatedMessage = true;
+				const name = expected.name ? `"${expected.name}" ` : "";
+				message = `The ${name}validation function is expected to return` + ` "true". Received ${inspect(res)}`;
+				if (actual instanceof Error) {
+					message += `\n\nCaught error:\n\n${actual}`;
+				}
+			}
+			throwError = true;
+		}
+	}
+	if (throwError) {
+		const err = new AssertionError({
+			actual,
+			expected,
+			message,
+			operator: fn.name,
+			stackStartFn: fn
+		});
+		err.generatedMessage = generatedMessage;
+		throw err;
+	}
+}
+function getActual(fn) {
+	// validateFunction(fn, "fn");
+	try {
+		fn();
+	} catch (error_) {
+		return error_;
+	}
+	return NO_EXCEPTION_SENTINEL;
+}
+function checkIsPromise(obj) {
+	// Accept native ES6 promises and promises that are implemented in a similar
+	// way. Do not accept thenables that use a function as `obj` and that have no
+	// `catch` handler.
+	return obj instanceof Promise || obj !== null && typeof obj === "object" && typeof obj.then === "function" && typeof obj.catch === "function";
+}
+function internalMatch(string, regexp, message, fn) {
+	if (!(regexp instanceof RegExp)) {
+		// @ts-expect-error
+		throw new ERR_INVALID_ARG_TYPE("regexp", "RegExp", regexp);
+	}
+	const match = fn === assert.match;
+	if (typeof string !== "string" || regexp.exec(string) !== null !== match) {
+		if (message instanceof Error) {
+			throw message;
+		}
+		const generatedMessage = !message;
+		// 'The input was expected to not match the regular expression ' +
+		message = message || (typeof string === "string" ? (match ? "The input did not match the regular expression " : "The input was expected to not match the regular expression ") + `${inspect(regexp)}. Input:\n\n${inspect(string)}\n` : "The \"string\" argument must be of type string. Received type " + `${typeof string} (${inspect(string)})`);
+		const err = new AssertionError({
+			actual: string,
+			expected: regexp,
+			message,
+			operator: fn?.name,
+			stackStartFn: fn
+		});
+		err.generatedMessage = generatedMessage;
+		throw err;
+	}
+}
+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 ERR_INVALID_RETURN_VALUE(
+				"instance of Promise",
+				"promiseFn",
+				// @ts-expect-error
+				resultPromise
+			);
+		}
+	} else if (checkIsPromise(promiseFn)) {
+		resultPromise = promiseFn;
+	} else {
+		throw new ERR_INVALID_ARG_TYPE(
+			"promiseFn",
+			["Function", "Promise"],
+			// @ts-expect-error
+			promiseFn
+		);
+	}
+	try {
+		await resultPromise;
+	} catch (error_) {
+		return error_;
+	}
+	return NO_EXCEPTION_SENTINEL;
+}
+function expectsError(stackStartFn, actual, error, message) {
+	if (typeof error === "string") {
+		if (arguments.length === 4) {
+			throw new ERR_INVALID_ARG_TYPE(
+				"error",
+				[
+					"Object",
+					"Error",
+					"Function",
+					"RegExp"
+				],
+				// @ts-expect-error
+				error
+			);
+		}
+		if (typeof actual === "object" && actual !== null) {
+			if (actual?.message === error) {
+				throw new ERR_AMBIGUOUS_ARGUMENT(
+					"error/message",
+					// @ts-expect-error
+					`The error message "${actual.message}" is identical to the message.`
+				);
+			}
+		} else if (actual === error) {
+			throw new ERR_AMBIGUOUS_ARGUMENT(
+				"error/message",
+				// @ts-expect-error
+				`The error "${actual}" is identical to the message.`
+			);
+		}
+		message = error;
+		error = undefined;
+	} else if (error != null && typeof error !== "object" && typeof error !== "function") {
+		throw new ERR_INVALID_ARG_TYPE(
+			"error",
+			[
+				"Object",
+				"Error",
+				"Function",
+				"RegExp"
+			],
+			// @ts-expect-error
+			error
+		);
+	}
+	if (actual === NO_EXCEPTION_SENTINEL) {
+		let details = "";
+		if (error && error.name) {
+			details += ` (${error.name})`;
+		}
+		details += message ? `: ${message}` : ".";
+		const fnType = stackStartFn === assert.rejects ? "rejection" : "exception";
+		innerFail({
+			actual: undefined,
+			expected: error,
+			operator: stackStartFn.name,
+			message: `Missing expected ${fnType}${details}`,
+			stackStartFn
+		});
+	}
+	if (!error) return;
+	expectedException(actual, error, message, stackStartFn);
+}
+function hasMatchingError(actual, expected) {
+	if (typeof expected !== "function") {
+		if (expected instanceof RegExp) {
+			const str = String(actual);
+			return RegExp.prototype.exec.call(expected, str) !== null;
+		}
+		throw new ERR_INVALID_ARG_TYPE(
+			"expected",
+			["Function", "RegExp"],
+			// @ts-expect-error
+			expected
+		);
+	}
+	// Guard instanceof against arrow functions as they don't have a prototype.
+	if (expected.prototype !== undefined && actual instanceof expected) {
+		return true;
+	}
+	if (expected instanceof Error) {
+		return false;
+	}
+	return Reflect.apply(expected, {}, [actual]) === true;
+}
+function expectsNoError(stackStartFn, actual, error, message) {
+	if (actual === NO_EXCEPTION_SENTINEL) return;
+	if (typeof error === "string") {
+		message = error;
+		error = undefined;
+	}
+	if (!error || hasMatchingError(actual, error)) {
+		const details = message ? `: ${message}` : ".";
+		const fnType = stackStartFn === assert.doesNotReject ? "rejection" : "exception";
+		innerFail({
+			actual,
+			expected: error,
+			operator: stackStartFn?.name,
+			message: `Got unwanted ${fnType}${details}\n` + `Actual message: "${actual && actual.message}"`,
+			stackStartFn
+		});
+	}
+	throw actual;
+}
+// ----------------------------------------------------------------------------
+// Exports
+// ----------------------------------------------------------------------------
+const assert = Object.assign(ok, {});
+// deprecated
+export const CallTracker = /* @__PURE__ */ notImplementedClass("asset.CallTracker");
+export const partialDeepStrictEqual = /* @__PURE__ */ notImplemented("assert.partialDeepStrictEqual");
+assert.fail = fail;
+assert.ok = ok;
+assert.equal = equal;
+assert.notEqual = notEqual;
+assert.deepEqual = deepEqual;
+assert.notDeepEqual = notDeepEqual;
+assert.deepStrictEqual = deepStrictEqual;
+assert.notDeepStrictEqual = notDeepStrictEqual;
+assert.strictEqual = strictEqual;
+assert.notStrictEqual = notStrictEqual;
+assert.throws = throws;
+assert.rejects = rejects;
+assert.doesNotThrow = doesNotThrow;
+assert.doesNotReject = doesNotReject;
+assert.ifError = ifError;
+assert.match = match;
+assert.doesNotMatch = doesNotMatch;
+assert.partialDeepStrictEqual = partialDeepStrictEqual;
+assert.AssertionError = AssertionError;
+assert.CallTracker = CallTracker;
+export const strict = Object.assign(function _strict(...args) {
+	// @ts-expect-error
+	innerOk(strict, args.length, ...args);
+}, assert, {
+	equal: assert.strictEqual,
+	deepEqual: assert.deepStrictEqual,
+	notEqual: assert.notStrictEqual,
+	notDeepEqual: assert.notDeepStrictEqual
+});
+assert.strict = strict;
+assert.strict.strict = assert.strict;
+export default assert;