How to use the core-js-pure/features/set.prototype function in core-js-pure

QUnit.test('Set#filter', assert => {
  const { filter } = Set.prototype;

  assert.isFunction(filter);
  assert.arity(filter, 1);
  assert.name(filter, 'filter');
  assert.nonEnumerable(Set.prototype, 'filter');

  const set = new Set([1]);
  const context = {};
  set.filter(function (value, key, that) {
    assert.same(arguments.length, 3, 'correct number of callback arguments');
    assert.same(value, 1, 'correct value in callback');
    assert.same(key, 1, 'correct key in callback');
    assert.same(that, set, 'correct link to set in callback');
    assert.same(this, context, 'correct callback context');
  }, context);

  assert.ok(new Set().filter(it => it) instanceof Set);

  assert.deepEqual(from(new Set([1, 2, 3, 'q', {}, 4, true, 5]).filter(it => typeof it === 'number')), [1, 2, 3, 4, 5]);

  assert.throws(() => filter.call({}, () => { /* empty */ }), TypeError);

QUnit.test('Set#symmetricDifference', assert => {
  const { symmetricDifference } = Set.prototype;

  assert.isFunction(symmetricDifference);
  assert.arity(symmetricDifference, 1);
  assert.name(symmetricDifference, 'symmetricDifference');
  assert.nonEnumerable(Set.prototype, 'symmetricDifference');

  const set = new Set([1]);
  assert.ok(set.symmetricDifference([2]) !== set);

  assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference([4, 5])), [1, 2, 3, 4, 5]);
  assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference([3, 4])), [1, 2, 4]);
  assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference(createIterable([3, 4]))), [1, 2, 4]);

  assert.throws(() => new Set([1, 2, 3]).symmetricDifference(), TypeError);

  assert.throws(() => symmetricDifference.call({}, [1, 2, 3]), TypeError);

QUnit.test('Set#intersect', assert => {
  const { intersect } = Set.prototype;

  assert.isFunction(intersect);
  assert.arity(intersect, 1);
  if ('name' in intersect) assert.name(intersect, 'intersect');
  assert.nonEnumerable(Set.prototype, 'intersect');

  const set = new Set([1]);
  assert.ok(set.intersect([2]) !== set);

  assert.deepEqual(from(new Set([1, 2, 3]).intersect([4, 5])), []);
  assert.deepEqual(from(new Set([1, 2, 3]).intersect([2, 3, 4])), [2, 3]);
  assert.deepEqual(from(new Set([1, 2, 3]).intersect(createIterable([2, 3, 4]))), [2, 3]);

  assert.throws(() => new Set([1, 2, 3]).intersect(), TypeError);

  assert.throws(() => intersect.call({}, [1, 2, 3]), TypeError);

QUnit.test('Set#map', assert => {
  const { map } = Set.prototype;

  assert.isFunction(map);
  assert.arity(map, 1);
  assert.name(map, 'map');
  assert.nonEnumerable(Set.prototype, 'map');

  const set = new Set([1]);
  const context = {};
  set.map(function (value, key, that) {
    assert.same(arguments.length, 3, 'correct number of callback arguments');
    assert.same(value, 1, 'correct value in callback');
    assert.same(key, 1, 'correct key in callback');
    assert.same(that, set, 'correct link to set in callback');
    assert.same(this, context, 'correct callback context');
  }, context);

QUnit.test('Set#find', assert => {
  const { find } = Set.prototype;

  assert.isFunction(find);
  assert.arity(find, 1);
  assert.name(find, 'find');
  assert.nonEnumerable(Set.prototype, 'find');

  const set = new Set([1]);
  const context = {};
  set.find(function (value, key, that) {
    assert.same(arguments.length, 3, 'correct number of callback arguments');
    assert.same(value, 1, 'correct value in callback');
    assert.same(key, 1, 'correct key in callback');
    assert.same(that, set, 'correct link to set in callback');
    assert.same(this, context, 'correct callback context');
  }, context);

QUnit.test('Set#deleteAll', assert => {
  const { deleteAll } = Set.prototype;

  assert.isFunction(deleteAll);
  assert.arity(deleteAll, 0);
  assert.name(deleteAll, 'deleteAll');
  assert.nonEnumerable(Set.prototype, 'deleteAll');

  let set = new Set([1, 2, 3]);
  assert.same(set.deleteAll(1, 2), true);
  assert.deepEqual(from(set), [3]);

  set = new Set([1, 2, 3]);
  assert.same(set.deleteAll(3, 4), false);
  assert.deepEqual(from(set), [1, 2]);

  set = new Set([1, 2, 3]);
  assert.same(set.deleteAll(4, 5), false);

QUnit.test('Set#symmetricDifference', assert => {
  const { symmetricDifference } = Set.prototype;

  assert.isFunction(symmetricDifference);
  assert.arity(symmetricDifference, 1);
  assert.name(symmetricDifference, 'symmetricDifference');
  assert.nonEnumerable(Set.prototype, 'symmetricDifference');

  const set = new Set([1]);
  assert.ok(set.symmetricDifference([2]) !== set);

  assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference([4, 5])), [1, 2, 3, 4, 5]);
  assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference([3, 4])), [1, 2, 4]);
  assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference(createIterable([3, 4]))), [1, 2, 4]);

  assert.throws(() => new Set([1, 2, 3]).symmetricDifference(), TypeError);

  assert.throws(() => symmetricDifference.call({}, [1, 2, 3]), TypeError);
  assert.throws(() => symmetricDifference.call(undefined, [1, 2, 3]), TypeError);
  assert.throws(() => symmetricDifference.call(null, [1, 2, 3]), TypeError);
});

QUnit.test('Set#intersect', assert => {
  const { intersect } = Set.prototype;

  assert.isFunction(intersect);
  assert.arity(intersect, 1);
  if ('name' in intersect) assert.name(intersect, 'intersect');
  assert.nonEnumerable(Set.prototype, 'intersect');

  const set = new Set([1]);
  assert.ok(set.intersect([2]) !== set);

  assert.deepEqual(from(new Set([1, 2, 3]).intersect([4, 5])), []);
  assert.deepEqual(from(new Set([1, 2, 3]).intersect([2, 3, 4])), [2, 3]);
  assert.deepEqual(from(new Set([1, 2, 3]).intersect(createIterable([2, 3, 4]))), [2, 3]);

  assert.throws(() => new Set([1, 2, 3]).intersect(), TypeError);

  assert.throws(() => intersect.call({}, [1, 2, 3]), TypeError);
  assert.throws(() => intersect.call(undefined, [1, 2, 3]), TypeError);
  assert.throws(() => intersect.call(null, [1, 2, 3]), TypeError);
});

QUnit.test('Set#isSubsetOf', assert => {
  const { isSubsetOf } = Set.prototype;

  assert.isFunction(isSubsetOf);
  assert.arity(isSubsetOf, 1);
  assert.name(isSubsetOf, 'isSubsetOf');
  assert.nonEnumerable(Set.prototype, 'isSubsetOf');

  assert.ok(new Set([1]).isSubsetOf([1, 2, 3]));
  assert.ok(!new Set([1]).isSubsetOf([2, 3, 4]));
  assert.ok(new Set([1, 2, 3]).isSubsetOf([5, 4, 3, 2, 1]));
  assert.ok(!new Set([1, 2, 3]).isSubsetOf([5, 4, 3, 2]));

  assert.ok(new Set([1]).isSubsetOf(createIterable([1, 2, 3])));
  assert.ok(!new Set([1]).isSubsetOf(createIterable([2, 3, 4])));

  assert.ok(new Set([1]).isSubsetOf({ has: () => true }));
  assert.ok(!new Set([1]).isSubsetOf({ has: () => false }));

  assert.ok(isSubsetOf.call('ab', ['a', 'b', 'c']));
  assert.ok(!isSubsetOf.call('ab', ['a']));

  assert.throws(() => new Set([1, 2, 3]).isSubsetOf(), TypeError);

QUnit.test('Set#some', assert => {
  const { some } = Set.prototype;

  assert.isFunction(some);
  assert.arity(some, 1);
  assert.name(some, 'some');
  assert.nonEnumerable(Set.prototype, 'some');

  const set = new Set([1]);
  const context = {};
  set.some(function (value, key, that) {
    assert.same(arguments.length, 3, 'correct number of callback arguments');
    assert.same(value, 1, 'correct value in callback');
    assert.same(key, 1, 'correct key in callback');
    assert.same(that, set, 'correct link to set in callback');
    assert.same(this, context, 'correct callback context');
  }, context);

  assert.same(new Set([1, 2, 3]).some(it => typeof it === 'number'), true);
  assert.same(new Set(['1', '2', '3']).some(it => typeof it === 'number'), false);
  assert.same(new Set([1, '2', 3]).some(it => typeof it === 'number'), true);
  assert.same(new Set().some(it => typeof it === 'number'), false);