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

QUnit.test('Map#mapKeys', assert => {
  const { mapKeys } = Map.prototype;

  assert.isFunction(mapKeys);
  assert.arity(mapKeys, 1);
  assert.name(mapKeys, 'mapKeys');
  assert.nonEnumerable(Map.prototype, 'mapKeys');

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

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

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

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

QUnit.test('Map#merge', assert => {
  const { merge } = Map.prototype;

  assert.isFunction(merge);
  assert.arity(merge, 1);
  assert.name(merge, 'merge');
  assert.nonEnumerable(Map.prototype, 'merge');

  const map = new Map([[1, 2]]);
  const result = map.merge([[3, 4]]);
  assert.ok(result === map);
  assert.ok(result instanceof Map);

  assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([[5, 6]])), [[1, 2], [3, 4], [5, 6]]);
  assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([[3, 5], [5, 6]])), [[1, 2], [3, 5], [5, 6]]);
  assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([])), [[1, 2], [3, 4]]);

  assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([[3, 5]], [[5, 6]])), [[1, 2], [3, 5], [5, 6]]);

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

QUnit.test('Map#mapValues', assert => {
  const { mapValues } = Map.prototype;

  assert.isFunction(mapValues);
  assert.arity(mapValues, 1);
  assert.name(mapValues, 'mapValues');
  assert.nonEnumerable(Map.prototype, 'mapValues');

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

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

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

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

  assert.deepEqual(from(new Map([
    ['a', 1],
    [1, 2],
    ['b', 3],
    [2, 'q'],

QUnit.test('Map#reduce', assert => {
  const { reduce } = Map.prototype;

  assert.isFunction(reduce);
  assert.arity(reduce, 1);
  assert.name(reduce, 'reduce');
  assert.nonEnumerable(Map.prototype, 'reduce');

  const set = new Map([['a', 1]]);
  const accumulator = {};
  set.reduce(function (memo, value, key, that) {
    assert.same(arguments.length, 4, 'correct number of callback arguments');
    assert.same(memo, accumulator, 'correct callback accumulator');
    assert.same(value, 1, 'correct value in callback');
    assert.same(key, 'a', 'correct index in callback');
    assert.same(that, set, 'correct link to set in callback');
  }, accumulator);

QUnit.test('Map#keyOf', assert => {
  const { keyOf } = Map.prototype;
  assert.isFunction(keyOf);
  assert.arity(keyOf, 1);
  assert.nonEnumerable(Map.prototype, 'keyOf');

  const object = {};
  const map = new Map([[1, 1], [2, 2], [3, 3], [4, -0], [5, object], [6, NaN]]);
  assert.same(map.keyOf(1), 1);
  assert.same(map.keyOf(-0), 4);
  assert.same(map.keyOf(0), 4);
  assert.same(map.keyOf(object), 5);
  assert.same(map.keyOf(4), undefined);
  assert.same(map.keyOf(-0.5), undefined);
  assert.same(map.keyOf({}), undefined);
  assert.same(map.keyOf(NaN), undefined);

  assert.throws(() => keyOf.call({}, 1), TypeError);

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

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

  const set = new Map([[1, 2]]);
  const context = {};
  set.find(function (value, key, that) {
    assert.same(arguments.length, 3, 'correct number of callback arguments');
    assert.same(value, 2, '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 Map([[1, 2], [2, 3], [3, 4]]).find(it => it % 2), 3);

QUnit.test('Map#mapValues', assert => {
  const { mapValues } = Map.prototype;

  assert.isFunction(mapValues);
  assert.arity(mapValues, 1);
  assert.name(mapValues, 'mapValues');
  assert.nonEnumerable(Map.prototype, 'mapValues');

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

  assert.ok(new Map().mapValues(it => it) instanceof Map);

  assert.deepEqual(from(new Map([
    ['a', 1],
    [1, 2],

QUnit.test('Map#mapKeys', assert => {
  const { mapKeys } = Map.prototype;

  assert.isFunction(mapKeys);
  assert.arity(mapKeys, 1);
  assert.name(mapKeys, 'mapKeys');
  assert.nonEnumerable(Map.prototype, 'mapKeys');

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

  assert.ok(new Map().mapKeys(it => it) instanceof Map);

  assert.deepEqual(from(new Map([
    ['a', 1],
    [1, 2],