Index: frontend/node_modules/define-data-property/test/index.js
===================================================================
--- frontend/node_modules/define-data-property/test/index.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/define-data-property/test/index.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,392 @@
+'use strict';
+
+var test = require('tape');
+var v = require('es-value-fixtures');
+var forEach = require('for-each');
+var inspect = require('object-inspect');
+var hasOwn = require('hasown');
+var hasPropertyDescriptors = require('has-property-descriptors')();
+var getOwnPropertyDescriptors = require('object.getownpropertydescriptors');
+var ownKeys = require('reflect.ownkeys');
+
+var defineDataProperty = require('../');
+
+test('defineDataProperty', function (t) {
+	t.test('argument validation', function (st) {
+		forEach(v.primitives, function (nonObject) {
+			st['throws'](
+				// @ts-expect-error
+				function () { defineDataProperty(nonObject, 'key', 'value'); },
+				TypeError,
+				'throws on non-object input: ' + inspect(nonObject)
+			);
+		});
+
+		forEach(v.nonPropertyKeys, function (nonPropertyKey) {
+			st['throws'](
+				// @ts-expect-error
+				function () { defineDataProperty({}, nonPropertyKey, 'value'); },
+				TypeError,
+				'throws on non-PropertyKey input: ' + inspect(nonPropertyKey)
+			);
+		});
+
+		forEach(v.nonBooleans, function (nonBoolean) {
+			if (nonBoolean !== null) {
+				st['throws'](
+					// @ts-expect-error
+					function () { defineDataProperty({}, 'key', 'value', nonBoolean); },
+					TypeError,
+					'throws on non-boolean nonEnumerable: ' + inspect(nonBoolean)
+				);
+
+				st['throws'](
+					// @ts-expect-error
+					function () { defineDataProperty({}, 'key', 'value', false, nonBoolean); },
+					TypeError,
+					'throws on non-boolean nonWritable: ' + inspect(nonBoolean)
+				);
+
+				st['throws'](
+					// @ts-expect-error
+					function () { defineDataProperty({}, 'key', 'value', false, false, nonBoolean); },
+					TypeError,
+					'throws on non-boolean nonConfigurable: ' + inspect(nonBoolean)
+				);
+			}
+		});
+
+		st.end();
+	});
+
+	t.test('normal data property', function (st) {
+		/** @type {Record<PropertyKey, string>} */
+		var obj = { existing: 'existing property' };
+		st.ok(hasOwn(obj, 'existing'), 'has initial own property');
+		st.equal(obj.existing, 'existing property', 'has expected initial value');
+
+		var res = defineDataProperty(obj, 'added', 'added property');
+		st.equal(res, void undefined, 'returns `undefined`');
+		st.ok(hasOwn(obj, 'added'), 'has expected own property');
+		st.equal(obj.added, 'added property', 'has expected value');
+
+		defineDataProperty(obj, 'existing', 'new value');
+		st.ok(hasOwn(obj, 'existing'), 'still has expected own property');
+		st.equal(obj.existing, 'new value', 'has new expected value');
+
+		defineDataProperty(obj, 'explicit1', 'new value', false);
+		st.ok(hasOwn(obj, 'explicit1'), 'has expected own property (explicit enumerable)');
+		st.equal(obj.explicit1, 'new value', 'has new expected value (explicit enumerable)');
+
+		defineDataProperty(obj, 'explicit2', 'new value', false, false);
+		st.ok(hasOwn(obj, 'explicit2'), 'has expected own property (explicit writable)');
+		st.equal(obj.explicit2, 'new value', 'has new expected value (explicit writable)');
+
+		defineDataProperty(obj, 'explicit3', 'new value', false, false, false);
+		st.ok(hasOwn(obj, 'explicit3'), 'has expected own property (explicit configurable)');
+		st.equal(obj.explicit3, 'new value', 'has new expected value (explicit configurable)');
+
+		st.end();
+	});
+
+	t.test('loose mode', { skip: !hasPropertyDescriptors }, function (st) {
+		var obj = { existing: 'existing property' };
+
+		defineDataProperty(obj, 'added', 'added value 1', true, null, null, true);
+		st.deepEqual(
+			getOwnPropertyDescriptors(obj),
+			{
+				existing: {
+					configurable: true,
+					enumerable: true,
+					value: 'existing property',
+					writable: true
+				},
+				added: {
+					configurable: true,
+					enumerable: !hasPropertyDescriptors,
+					value: 'added value 1',
+					writable: true
+				}
+			},
+			'in loose mode, obj still adds property 1'
+		);
+
+		defineDataProperty(obj, 'added', 'added value 2', false, true, null, true);
+		st.deepEqual(
+			getOwnPropertyDescriptors(obj),
+			{
+				existing: {
+					configurable: true,
+					enumerable: true,
+					value: 'existing property',
+					writable: true
+				},
+				added: {
+					configurable: true,
+					enumerable: true,
+					value: 'added value 2',
+					writable: !hasPropertyDescriptors
+				}
+			},
+			'in loose mode, obj still adds property 2'
+		);
+
+		defineDataProperty(obj, 'added', 'added value 3', false, false, true, true);
+		st.deepEqual(
+			getOwnPropertyDescriptors(obj),
+			{
+				existing: {
+					configurable: true,
+					enumerable: true,
+					value: 'existing property',
+					writable: true
+				},
+				added: {
+					configurable: !hasPropertyDescriptors,
+					enumerable: true,
+					value: 'added value 3',
+					writable: true
+				}
+			},
+			'in loose mode, obj still adds property 3'
+		);
+
+		st.end();
+	});
+
+	t.test('non-normal data property, ES3', { skip: hasPropertyDescriptors }, function (st) {
+		/** @type {Record<PropertyKey, string>} */
+		var obj = { existing: 'existing property' };
+
+		st['throws'](
+			function () { defineDataProperty(obj, 'added', 'added value', true); },
+			SyntaxError,
+			'nonEnumerable throws a Syntax Error'
+		);
+
+		st['throws'](
+			function () { defineDataProperty(obj, 'added', 'added value', false, true); },
+			SyntaxError,
+			'nonWritable throws a Syntax Error'
+		);
+
+		st['throws'](
+			function () { defineDataProperty(obj, 'added', 'added value', false, false, true); },
+			SyntaxError,
+			'nonWritable throws a Syntax Error'
+		);
+
+		st.deepEqual(
+			ownKeys(obj),
+			['existing'],
+			'obj still has expected keys'
+		);
+		st.equal(obj.existing, 'existing property', 'obj still has expected values');
+
+		st.end();
+	});
+
+	t.test('new non-normal data property, ES5+', { skip: !hasPropertyDescriptors }, function (st) {
+		/** @type {Record<PropertyKey, string>} */
+		var obj = { existing: 'existing property' };
+
+		defineDataProperty(obj, 'nonEnum', null, true);
+		defineDataProperty(obj, 'nonWrit', null, false, true);
+		defineDataProperty(obj, 'nonConf', null, false, false, true);
+
+		st.deepEqual(
+			getOwnPropertyDescriptors(obj),
+			{
+				existing: {
+					configurable: true,
+					enumerable: true,
+					value: 'existing property',
+					writable: true
+				},
+				nonEnum: {
+					configurable: true,
+					enumerable: false,
+					value: null,
+					writable: true
+				},
+				nonWrit: {
+					configurable: true,
+					enumerable: true,
+					value: null,
+					writable: false
+				},
+				nonConf: {
+					configurable: false,
+					enumerable: true,
+					value: null,
+					writable: true
+				}
+			},
+			'obj has expected property descriptors'
+		);
+
+		st.end();
+	});
+
+	t.test('existing non-normal data property, ES5+', { skip: !hasPropertyDescriptors }, function (st) {
+		// test case changing an existing non-normal property
+
+		/** @type {Record<string, null | string>} */
+		var obj = {};
+		Object.defineProperty(obj, 'nonEnum', { configurable: true, enumerable: false, value: null, writable: true });
+		Object.defineProperty(obj, 'nonWrit', { configurable: true, enumerable: true, value: null, writable: false });
+		Object.defineProperty(obj, 'nonConf', { configurable: false, enumerable: true, value: null, writable: true });
+
+		st.deepEqual(
+			getOwnPropertyDescriptors(obj),
+			{
+				nonEnum: {
+					configurable: true,
+					enumerable: false,
+					value: null,
+					writable: true
+				},
+				nonWrit: {
+					configurable: true,
+					enumerable: true,
+					value: null,
+					writable: false
+				},
+				nonConf: {
+					configurable: false,
+					enumerable: true,
+					value: null,
+					writable: true
+				}
+			},
+			'obj initially has expected property descriptors'
+		);
+
+		defineDataProperty(obj, 'nonEnum', 'new value', false);
+		defineDataProperty(obj, 'nonWrit', 'new value', false, false);
+		st['throws'](
+			function () { defineDataProperty(obj, 'nonConf', 'new value', false, false, false); },
+			TypeError,
+			'can not alter a nonconfigurable property'
+		);
+
+		st.deepEqual(
+			getOwnPropertyDescriptors(obj),
+			{
+				nonEnum: {
+					configurable: true,
+					enumerable: true,
+					value: 'new value',
+					writable: true
+				},
+				nonWrit: {
+					configurable: true,
+					enumerable: true,
+					value: 'new value',
+					writable: true
+				},
+				nonConf: {
+					configurable: false,
+					enumerable: true,
+					value: null,
+					writable: true
+				}
+			},
+			'obj ends up with expected property descriptors'
+		);
+
+		st.end();
+	});
+
+	t.test('frozen object, ES5+', { skip: !hasPropertyDescriptors }, function (st) {
+		var frozen = Object.freeze({ existing: true });
+
+		st['throws'](
+			function () { defineDataProperty(frozen, 'existing', 'new value'); },
+			TypeError,
+			'frozen object can not modify an existing property'
+		);
+
+		st['throws'](
+			function () { defineDataProperty(frozen, 'new', 'new property'); },
+			TypeError,
+			'frozen object can not add a new property'
+		);
+
+		st.end();
+	});
+
+	t.test('sealed object, ES5+', { skip: !hasPropertyDescriptors }, function (st) {
+		var sealed = Object.seal({ existing: true });
+		st.deepEqual(
+			Object.getOwnPropertyDescriptor(sealed, 'existing'),
+			{
+				configurable: false,
+				enumerable: true,
+				value: true,
+				writable: true
+			},
+			'existing value on sealed object has expected descriptor'
+		);
+
+		defineDataProperty(sealed, 'existing', 'new value');
+
+		st.deepEqual(
+			Object.getOwnPropertyDescriptor(sealed, 'existing'),
+			{
+				configurable: false,
+				enumerable: true,
+				value: 'new value',
+				writable: true
+			},
+			'existing value on sealed object has changed descriptor'
+		);
+
+		st['throws'](
+			function () { defineDataProperty(sealed, 'new', 'new property'); },
+			TypeError,
+			'sealed object can not add a new property'
+		);
+
+		st.end();
+	});
+
+	t.test('nonextensible object, ES5+', { skip: !hasPropertyDescriptors }, function (st) {
+		var nonExt = Object.preventExtensions({ existing: true });
+
+		st.deepEqual(
+			Object.getOwnPropertyDescriptor(nonExt, 'existing'),
+			{
+				configurable: true,
+				enumerable: true,
+				value: true,
+				writable: true
+			},
+			'existing value on non-extensible object has expected descriptor'
+		);
+
+		defineDataProperty(nonExt, 'existing', 'new value', true);
+
+		st.deepEqual(
+			Object.getOwnPropertyDescriptor(nonExt, 'existing'),
+			{
+				configurable: true,
+				enumerable: false,
+				value: 'new value',
+				writable: true
+			},
+			'existing value on non-extensible object has changed descriptor'
+		);
+
+		st['throws'](
+			function () { defineDataProperty(nonExt, 'new', 'new property'); },
+			TypeError,
+			'non-extensible object can not add a new property'
+		);
+
+		st.end();
+	});
+
+	t.end();
+});