Diffusion Ant (master) Code

ant/tests/test_reflect_construct_newtarget_wrappers.cjs
e35c3ed2ab40master

test_reflect_construct_newtarget_wrappers.cjs
View Options

			function assert(condition, message) {
			if (!condition) throw new Error(message);
			}

			const BooleanNewTarget = function BooleanNewTarget() {};
			const booleanObject = Reflect.construct(Boolean, [], BooleanNewTarget);

			assert(
			Boolean.prototype.valueOf.call(booleanObject) === false,
			'Reflect.construct(Boolean, [], newTarget) should initialize [[BooleanData]]',
			);
			assert(
			Object.getPrototypeOf(booleanObject) === BooleanNewTarget.prototype,
			'Reflect.construct(Boolean, [], newTarget) should use newTarget.prototype',
			);

			const NumberNewTarget = function NumberNewTarget() {};
			const numberObject = Reflect.construct(Number, [42], NumberNewTarget);

			assert(
			Number.prototype.valueOf.call(numberObject) === 42,
			'Reflect.construct(Number, [], newTarget) should initialize [[NumberData]]',
			);
			assert(
			Object.getPrototypeOf(numberObject) === NumberNewTarget.prototype,
			'Reflect.construct(Number, [], newTarget) should use newTarget.prototype',
			);

			const StringNewTarget = function StringNewTarget() {};
			const stringObject = Reflect.construct(String, ['ant'], StringNewTarget);

			assert(
			String.prototype.valueOf.call(stringObject) === 'ant',
			'Reflect.construct(String, [], newTarget) should initialize [[StringData]]',
			);
			assert(
			Object.getPrototypeOf(stringObject) === StringNewTarget.prototype,
			'Reflect.construct(String, [], newTarget) should use newTarget.prototype',
			);

			function supportsReflectConstructNewTarget() {
			try {
			return !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
			} catch (_) {
			return false;
			}
			}

			function inherit(Sub, Super) {
			Sub.prototype = Object.create(Super && Super.prototype, {
			constructor: { value: Sub, writable: true, configurable: true },
			});
			Object.defineProperty(Sub, 'prototype', { writable: false });
			if (Super) Object.setPrototypeOf(Sub, Super);
			}

			function getPrototypeOf(value) {
			return Object.getPrototypeOf.bind()(value);
			}

			function constructSuper(self, Constructor, args) {
			const Super = getPrototypeOf(Constructor);
			return Reflect.construct(Super, args \|\| [], getPrototypeOf(self).constructor);
			}

			const SafeWeakMap = (function(Super) {
			function SafeWeakMap(iterable) {
			return constructSuper(this, SafeWeakMap, [iterable]);
			}
			inherit(SafeWeakMap, Super);
			Object.setPrototypeOf(SafeWeakMap.prototype, null);
			Object.freeze(SafeWeakMap.prototype);
			Object.freeze(SafeWeakMap);
			return SafeWeakMap;
			})(WeakMap);

			assert(supportsReflectConstructNewTarget(), 'Reflect.construct newTarget probe should pass');

			const safeWeakMap = new SafeWeakMap();
			assert(safeWeakMap instanceof SafeWeakMap, 'derived WeakMap should use derived prototype');

			console.log('reflect:construct-newtarget-wrappers:ok');

Owner Packages

No Owners