merge-anything 3.0.7 → 4.0.3

package/dist/index.cjs.js

@@ -1,134 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var isWhat = require('is-what');
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
-
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
-
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
-***************************************************************************** */
-
-function __spreadArrays() {
-    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
-    for (var r = Array(s), k = 0, i = 0; i < il; i++)
-        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
-            r[k] = a[j];
-    return r;
-}
-
-function concatArrays(originVal, newVal) {
-    if (isWhat.isArray(originVal) && isWhat.isArray(newVal)) {
-        // concat logic
-        return originVal.concat(newVal);
-    }
-    return newVal; // always return newVal as fallback!!
-}
-
-function assignProp(carry, key, newVal, originalObject) {
-    var propType = {}.propertyIsEnumerable.call(originalObject, key)
-        ? 'enumerable'
-        : 'nonenumerable';
-    if (propType === 'enumerable')
-        carry[key] = newVal;
-    if (propType === 'nonenumerable') {
-        Object.defineProperty(carry, key, {
-            value: newVal,
-            enumerable: false,
-            writable: true,
-            configurable: true,
-        });
-    }
-}
-function mergeRecursively(origin, newComer, compareFn) {
-    // always return newComer if its not an object
-    if (!isWhat.isPlainObject(newComer))
-        return newComer;
-    // define newObject to merge all values upon
-    var newObject = {};
-    if (isWhat.isPlainObject(origin)) {
-        var props_1 = Object.getOwnPropertyNames(origin);
-        var symbols_1 = Object.getOwnPropertySymbols(origin);
-        newObject = __spreadArrays(props_1, symbols_1).reduce(function (carry, key) {
-            var targetVal = origin[key];
-            if ((!isWhat.isSymbol(key) && !Object.getOwnPropertyNames(newComer).includes(key)) ||
-                (isWhat.isSymbol(key) && !Object.getOwnPropertySymbols(newComer).includes(key))) {
-                assignProp(carry, key, targetVal, origin);
-            }
-            return carry;
-        }, {});
-    }
-    // newObject has all properties that newComer hasn't
-    var props = Object.getOwnPropertyNames(newComer);
-    var symbols = Object.getOwnPropertySymbols(newComer);
-    var result = __spreadArrays(props, symbols).reduce(function (carry, key) {
-        // re-define the origin and newComer as targetVal and newVal
-        var newVal = newComer[key];
-        var targetVal = isWhat.isPlainObject(origin) ? origin[key] : undefined;
-        // When newVal is an object do the merge recursively
-        if (targetVal !== undefined && isWhat.isPlainObject(newVal)) {
-            newVal = mergeRecursively(targetVal, newVal, compareFn);
-        }
-        var propToAssign = compareFn ? compareFn(targetVal, newVal, key) : newVal;
-        assignProp(carry, key, propToAssign, newComer);
-        return carry;
-    }, newObject);
-    return result;
-}
-/**
- * Merge anything recursively.
- * Objects get merged, special objects (classes etc.) are re-assigned "as is".
- * Basic types overwrite objects or other basic types.
- *
- * @export
- * @template T
- * @template Tn
- * @param {T} origin
- * @param {...Tn} newComers
- * @returns {Assigned<T, Tn>}
- */
-function merge(origin) {
-    var newComers = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        newComers[_i - 1] = arguments[_i];
-    }
-    // @ts-ignore
-    return newComers.reduce(function (result, newComer) {
-        return mergeRecursively(result, newComer);
-    }, origin);
-}
-function mergeAndCompare(compareFn, origin) {
-    var newComers = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        newComers[_i - 2] = arguments[_i];
-    }
-    // @ts-ignore
-    return newComers.reduce(function (result, newComer) {
-        return mergeRecursively(result, newComer, compareFn);
-    }, origin);
-}
-function mergeAndConcat(origin) {
-    var newComers = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        newComers[_i - 1] = arguments[_i];
-    }
-    // @ts-ignore
-    return newComers.reduce(function (result, newComer) {
-        return mergeRecursively(result, newComer, concatArrays);
-    }, origin);
-}
-
-exports.concatArrays = concatArrays;
-exports.merge = merge;
-exports.mergeAndCompare = mergeAndCompare;
-exports.mergeAndConcat = mergeAndConcat;

package/dist/index.esm.js

@@ -1,127 +0,0 @@
-import { isArray, isPlainObject, isSymbol } from 'is-what';
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
-
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
-
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
-***************************************************************************** */
-
-function __spreadArrays() {
-    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
-    for (var r = Array(s), k = 0, i = 0; i < il; i++)
-        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
-            r[k] = a[j];
-    return r;
-}
-
-function concatArrays(originVal, newVal) {
-    if (isArray(originVal) && isArray(newVal)) {
-        // concat logic
-        return originVal.concat(newVal);
-    }
-    return newVal; // always return newVal as fallback!!
-}
-
-function assignProp(carry, key, newVal, originalObject) {
-    var propType = {}.propertyIsEnumerable.call(originalObject, key)
-        ? 'enumerable'
-        : 'nonenumerable';
-    if (propType === 'enumerable')
-        carry[key] = newVal;
-    if (propType === 'nonenumerable') {
-        Object.defineProperty(carry, key, {
-            value: newVal,
-            enumerable: false,
-            writable: true,
-            configurable: true,
-        });
-    }
-}
-function mergeRecursively(origin, newComer, compareFn) {
-    // always return newComer if its not an object
-    if (!isPlainObject(newComer))
-        return newComer;
-    // define newObject to merge all values upon
-    var newObject = {};
-    if (isPlainObject(origin)) {
-        var props_1 = Object.getOwnPropertyNames(origin);
-        var symbols_1 = Object.getOwnPropertySymbols(origin);
-        newObject = __spreadArrays(props_1, symbols_1).reduce(function (carry, key) {
-            var targetVal = origin[key];
-            if ((!isSymbol(key) && !Object.getOwnPropertyNames(newComer).includes(key)) ||
-                (isSymbol(key) && !Object.getOwnPropertySymbols(newComer).includes(key))) {
-                assignProp(carry, key, targetVal, origin);
-            }
-            return carry;
-        }, {});
-    }
-    // newObject has all properties that newComer hasn't
-    var props = Object.getOwnPropertyNames(newComer);
-    var symbols = Object.getOwnPropertySymbols(newComer);
-    var result = __spreadArrays(props, symbols).reduce(function (carry, key) {
-        // re-define the origin and newComer as targetVal and newVal
-        var newVal = newComer[key];
-        var targetVal = isPlainObject(origin) ? origin[key] : undefined;
-        // When newVal is an object do the merge recursively
-        if (targetVal !== undefined && isPlainObject(newVal)) {
-            newVal = mergeRecursively(targetVal, newVal, compareFn);
-        }
-        var propToAssign = compareFn ? compareFn(targetVal, newVal, key) : newVal;
-        assignProp(carry, key, propToAssign, newComer);
-        return carry;
-    }, newObject);
-    return result;
-}
-/**
- * Merge anything recursively.
- * Objects get merged, special objects (classes etc.) are re-assigned "as is".
- * Basic types overwrite objects or other basic types.
- *
- * @export
- * @template T
- * @template Tn
- * @param {T} origin
- * @param {...Tn} newComers
- * @returns {Assigned<T, Tn>}
- */
-function merge(origin) {
-    var newComers = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        newComers[_i - 1] = arguments[_i];
-    }
-    // @ts-ignore
-    return newComers.reduce(function (result, newComer) {
-        return mergeRecursively(result, newComer);
-    }, origin);
-}
-function mergeAndCompare(compareFn, origin) {
-    var newComers = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        newComers[_i - 2] = arguments[_i];
-    }
-    // @ts-ignore
-    return newComers.reduce(function (result, newComer) {
-        return mergeRecursively(result, newComer, compareFn);
-    }, origin);
-}
-function mergeAndConcat(origin) {
-    var newComers = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        newComers[_i - 1] = arguments[_i];
-    }
-    // @ts-ignore
-    return newComers.reduce(function (result, newComer) {
-        return mergeRecursively(result, newComer, concatArrays);
-    }, origin);
-}
-
-export { concatArrays, merge, mergeAndCompare, mergeAndConcat };

package/src/extensions.ts

@@ -1,9 +0,0 @@
-import { isArray } from 'is-what'
-
-export function concatArrays (originVal: any, newVal: any): any | any[] {
-  if (isArray(originVal) && isArray(newVal)) {
-    // concat logic
-    return originVal.concat(newVal)
-  }
-  return newVal // always return newVal as fallback!!
-}

package/src/index.ts

@@ -1,2 +0,0 @@
-export { merge, mergeAndCompare, mergeAndConcat } from './merge'
-export { concatArrays } from './extensions'

package/src/merge.ts

@@ -1,110 +0,0 @@
-import { O } from 'ts-toolbelt'
-import { isPlainObject, isSymbol } from 'is-what'
-import { concatArrays } from './extensions'
-
-// @ts-ignore
-type PlainObject = { [key: string | symbol]: any }
-
-function assignProp (
-  carry: PlainObject,
-  key: string | symbol,
-  newVal: any,
-  originalObject: PlainObject
-): void {
-  const propType = {}.propertyIsEnumerable.call(originalObject, key)
-    ? 'enumerable'
-    : 'nonenumerable'
-  if (propType === 'enumerable') carry[key] = newVal
-  if (propType === 'nonenumerable') {
-    Object.defineProperty(carry, key, {
-      value: newVal,
-      enumerable: false,
-      writable: true,
-      configurable: true,
-    })
-  }
-}
-
-function mergeRecursively<T1 extends PlainObject | any, T2 extends PlainObject | any> (
-  origin: T1,
-  newComer: T2,
-  compareFn?: (prop1: any, prop2: any, propName: string | symbol) => any
-): (T1 & T2) | T2 {
-  // always return newComer if its not an object
-  if (!isPlainObject(newComer)) return newComer
-  // define newObject to merge all values upon
-  let newObject = {} as (T1 & T2) | T2
-  if (isPlainObject(origin)) {
-    const props = Object.getOwnPropertyNames(origin)
-    const symbols = Object.getOwnPropertySymbols(origin)
-    newObject = [...props, ...symbols].reduce((carry, key) => {
-      const targetVal = origin[key as any]
-      if (
-        (!isSymbol(key) && !Object.getOwnPropertyNames(newComer).includes(key)) ||
-        (isSymbol(key) && !Object.getOwnPropertySymbols(newComer).includes(key))
-      ) {
-        assignProp(carry as any, key, targetVal, origin)
-      }
-      return carry
-    }, {} as (T1 & T2) | T2)
-  }
-  // newObject has all properties that newComer hasn't
-  const props = Object.getOwnPropertyNames(newComer)
-  const symbols = Object.getOwnPropertySymbols(newComer)
-  const result = [...props, ...symbols].reduce((carry, key) => {
-    // re-define the origin and newComer as targetVal and newVal
-    let newVal = newComer[key as any]
-    const targetVal = isPlainObject(origin) ? origin[key as any] : undefined
-    // When newVal is an object do the merge recursively
-    if (targetVal !== undefined && isPlainObject(newVal)) {
-      newVal = mergeRecursively(targetVal, newVal, compareFn)
-    }
-    const propToAssign = compareFn ? compareFn(targetVal, newVal, key) : newVal
-    assignProp(carry as any, key, propToAssign, newComer)
-    return carry
-  }, newObject)
-  return result
-}
-
-/**
- * Merge anything recursively.
- * Objects get merged, special objects (classes etc.) are re-assigned "as is".
- * Basic types overwrite objects or other basic types.
- *
- * @export
- * @template T
- * @template Tn
- * @param {T} origin
- * @param {...Tn} newComers
- * @returns {Assigned<T, Tn>}
- */
-export function merge<T extends object, Tn extends object[]> (
-  origin: T,
-  ...newComers: Tn
-): O.Compact<T, Tn, 'deep'> {
-  // @ts-ignore
-  return newComers.reduce((result, newComer) => {
-    return mergeRecursively(result, newComer)
-  }, origin)
-}
-
-export function mergeAndCompare<T extends object, Tn extends object[]> (
-  compareFn: (prop1: any, prop2: any, propName: string | symbol) => any,
-  origin: T,
-  ...newComers: Tn
-): O.Compact<T, Tn, 'deep'> {
-  // @ts-ignore
-  return newComers.reduce((result, newComer) => {
-    return mergeRecursively(result, newComer, compareFn)
-  }, origin)
-}
-
-export function mergeAndConcat<T extends object, Tn extends object[]> (
-  origin: T,
-  ...newComers: Tn
-): O.Compact<T, Tn, 'deep'> {
-  // @ts-ignore
-  return newComers.reduce((result, newComer) => {
-    return mergeRecursively(result, newComer, concatArrays)
-  }, origin)
-}

package/test/index.ts

@@ -1,320 +0,0 @@
-import test from 'ava'
-import { isDate } from 'is-what'
-import { merge } from '../src/index'
-
-function copy<T> (any: T): T {
-  return JSON.parse(JSON.stringify(any))
-}
-
-test('1. origin & target stays the same | 2. works with dates', t => {
-  const nd = new Date()
-  const origin = { body: 'a' }
-  const target = { dueDate: nd }
-  const res = merge(origin, target)
-  t.deepEqual(res, { body: 'a', dueDate: nd })
-  t.deepEqual(origin, { body: 'a' })
-  t.deepEqual(target, { dueDate: nd })
-})
-test('adding a prop on target1|target2|mergedObj', t => {
-  const origin = { nested: {} }
-  const target = { nested: {} }
-  const res = merge(origin, target)
-  t.deepEqual(res, { nested: {} })
-  // @ts-ignore
-  origin.nested.a = ''
-  // @ts-ignore
-  target.nested.b = ''
-  // @ts-ignore
-  res.nested.c = ''
-  t.deepEqual(origin, { nested: { a: '' } })
-  t.deepEqual(target, { nested: { b: '' } })
-  t.deepEqual(res, { nested: { c: '' } })
-})
-test('changing a prop on target1|target2|mergedObj: failing example', t => {
-  const origin = { nested: { a: 1 } }
-  const target = {}
-  const res = merge(origin, target)
-  t.deepEqual(res, { nested: { a: 1 } })
-  origin.nested.a = 2
-  t.deepEqual(origin, { nested: { a: 2 } }) // linked
-  t.deepEqual(target, {})
-  t.deepEqual(res, { nested: { a: 2 } }) // linked
-  // @ts-ignore
-  target.nested = { a: 3 }
-  t.deepEqual(origin, { nested: { a: 2 } }) // not changed
-  t.deepEqual(target, { nested: { a: 3 } })
-  t.deepEqual(res, { nested: { a: 2 } }) // not changed
-  res.nested.a = 4
-  t.deepEqual(origin, { nested: { a: 4 } }) // linked
-  t.deepEqual(target, { nested: { a: 3 } })
-  t.deepEqual(res, { nested: { a: 4 } }) // linked
-})
-test('changing a prop on target1|target2|mergedObj: working example', t => {
-  const origin = { nested: { a: 1 } }
-  const target = {}
-  const merged = merge(origin, target)
-  const res = copy(merged)
-  t.deepEqual(res, { nested: { a: 1 } })
-  origin.nested.a = 2
-  t.deepEqual(origin, { nested: { a: 2 } }) // not linked
-  t.deepEqual(target, {})
-  t.deepEqual(res, { nested: { a: 1 } }) // not linked
-  // @ts-ignore
-  target.nested = { a: 3 }
-  t.deepEqual(origin, { nested: { a: 2 } }) // not changed
-  t.deepEqual(target, { nested: { a: 3 } })
-  t.deepEqual(res, { nested: { a: 1 } }) // not changed
-  res.nested.a = 4
-  t.deepEqual(origin, { nested: { a: 2 } }) // not linked
-  t.deepEqual(target, { nested: { a: 3 } })
-  t.deepEqual(res, { nested: { a: 4 } }) // not linked
-})
-test('1. works with multiple levels | 2. overwrites entire object with null', t => {
-  const origin = { body: '', head: null, toes: { big: true }, fingers: { '12': false } }
-  const target = { body: {}, head: {}, toes: {}, fingers: null }
-  const res = merge(origin, target)
-  // @ts-ignore
-  t.deepEqual(res, { body: {}, head: {}, toes: { big: true }, fingers: null })
-})
-test('origin and target are not modified', t => {
-  const origin = { body: '', head: null, toes: { big: true }, fingers: { '12': false } }
-  const target = { body: {}, head: {}, toes: {}, fingers: null }
-  const res = merge(origin, target)
-  // @ts-ignore
-  t.deepEqual(res, { body: {}, head: {}, toes: { big: true }, fingers: null })
-  t.deepEqual(origin, { body: '', head: null, toes: { big: true }, fingers: { '12': false } })
-  t.deepEqual(target, { body: {}, head: {}, toes: {}, fingers: null })
-  origin.body = 'a'
-  // @ts-ignore
-  origin.head = 'a'
-  // @ts-ignore
-  origin.toes.big = 'a'
-  // @ts-ignore
-  origin.fingers['12'] = 'a'
-  target.body = 'b'
-  target.head = 'b'
-  // @ts-ignore
-  target.toes = 'b'
-  // @ts-ignore
-  target.fingers = 'b'
-  // @ts-ignore
-  t.deepEqual(res, { body: {}, head: {}, toes: { big: true }, fingers: null })
-  // @ts-ignore
-  t.deepEqual(origin, { body: 'a', head: 'a', toes: { big: 'a' }, fingers: { '12': 'a' } })
-  // @ts-ignore
-  t.deepEqual(target, { body: 'b', head: 'b', toes: 'b', fingers: 'b' })
-})
-
-test('Overwrite arrays', t => {
-  const origin = { array: ['a'] }
-  const target = { array: ['b'] }
-  const res = merge(origin, target)
-  t.deepEqual(res, { array: ['b'] })
-})
-test('overwrites null with empty object', t => {
-  const origin = { body: null }
-  const target = { body: {} }
-  const res = merge(origin, target)
-  // @ts-ignore
-  t.deepEqual(res, { body: {} })
-})
-test('overwrites null with object with props', t => {
-  const origin = { body: null }
-  const target = { body: { props: true } }
-  const res = merge(origin, target)
-  // @ts-ignore
-  t.deepEqual(res, { body: { props: true } })
-})
-test('overwrites string values', t => {
-  const origin = { body: 'a' }
-  const target = { body: 'b' }
-  const res = merge(origin, target)
-  t.deepEqual(res, { body: 'b' })
-  t.deepEqual(origin, { body: 'a' })
-  t.deepEqual(target, { body: 'b' })
-})
-test('works with very deep props & dates', t => {
-  const newDate = new Date()
-  const origin = {
-    info: {
-      time: 'now',
-      newDate,
-      very: { deep: { prop: false } },
-    },
-  }
-  const target = {
-    info: {
-      date: 'tomorrow',
-      very: { deep: { prop: true } },
-    },
-  }
-  const res = merge(origin, target)
-  t.deepEqual(res, {
-    info: {
-      // @ts-ignore
-      time: 'now',
-      newDate,
-      date: 'tomorrow',
-      very: { deep: { prop: true } },
-    },
-  })
-  t.deepEqual(origin, {
-    info: {
-      time: 'now',
-      newDate,
-      very: { deep: { prop: false } },
-    },
-  })
-  t.deepEqual(target, {
-    info: {
-      date: 'tomorrow',
-      very: { deep: { prop: true } },
-    },
-  })
-  // @ts-ignore
-  t.true(isDate(res.info.newDate))
-})
-test('1. does not overwrite origin prop if target prop is an empty object | 2. properly merges deep props', t => {
-  const origin = {
-    info: {
-      time: { when: 'now' },
-      very: { deep: { prop: false } },
-    },
-  }
-  const target = {
-    info: {
-      time: {},
-      very: { whole: 1 },
-    },
-  }
-  const res = merge(origin, target)
-  t.deepEqual(res, {
-    info: {
-      time: { when: 'now' },
-      very: {
-        // @ts-ignore
-        deep: { prop: false },
-        whole: 1,
-      },
-    },
-  })
-})
-test('overwrites any origin prop when target prop is an object with props', t => {
-  const origin = {
-    body: 'a',
-    body2: { head: false },
-    tail: {},
-  }
-  const target = {
-    body: { head: true },
-    body2: { head: { eyes: true } },
-  }
-  const res = merge(origin, target)
-  t.deepEqual(res, {
-    // @ts-ignore
-    body: { head: true },
-    // @ts-ignore
-    body2: { head: { eyes: true } },
-    tail: {},
-  })
-  t.deepEqual(origin, {
-    body: 'a',
-    body2: { head: false },
-    tail: {},
-  })
-  t.deepEqual(target, {
-    body: { head: true },
-    body2: { head: { eyes: true } },
-  })
-})
-
-test('works with unlimited depth', t => {
-  const date = new Date()
-  const origin = { origin: 'a', t2: false, t3: {}, t4: 'false' }
-  const t1 = { t1: date }
-  const t2 = { t2: 'new' }
-  const t3 = { t3: 'new' }
-  const t4 = { t4: 'new', t3: {} }
-  const res = merge(origin, t1, t2, t3, t4)
-  // @ts-ignore
-  t.deepEqual(res, { origin: 'a', t1: date, t2: 'new', t3: {}, t4: 'new' })
-  t.deepEqual(origin, { origin: 'a', t2: false, t3: {}, t4: 'false' })
-  t.deepEqual(t1, { t1: date })
-  t.deepEqual(t2, { t2: 'new' })
-  t.deepEqual(t3, { t3: 'new' })
-  t.deepEqual(t4, { t4: 'new', t3: {} })
-})
-
-test('symbols as keys 1', t => {
-  const mySymbol = Symbol('mySymbol')
-  const x = { value: 42, [mySymbol]: 'hello' }
-  const y = { other: 33 }
-  const res = merge(x, y)
-  t.is(res.value, 42)
-  t.is(res.other, 33)
-  t.is(res[mySymbol], 'hello')
-})
-test('symbols as keys 2', t => {
-  const mySymbol = Symbol('mySymbol')
-  const x = { value: 42 }
-  const y = { other: 33, [mySymbol]: 'hello' }
-  const res = merge(x, y)
-  t.is(res.value, 42)
-  t.is(res.other, 33)
-  t.is(res[mySymbol], 'hello')
-})
-
-test('nonenumerable keys', t => {
-  const mySymbol = Symbol('mySymbol')
-  const x = { value: 42 }
-  const y = { other: 33 }
-  Object.defineProperty(x, 'xid', {
-    value: 1,
-    writable: true,
-    enumerable: false,
-    configurable: true,
-  })
-  Object.defineProperty(x, mySymbol, {
-    value: 'original',
-    writable: true,
-    enumerable: false,
-    configurable: true,
-  })
-  Object.defineProperty(y, 'yid', {
-    value: 2,
-    writable: true,
-    enumerable: false,
-    configurable: true,
-  })
-  Object.defineProperty(y, mySymbol, {
-    value: 'new',
-    writable: true,
-    enumerable: false,
-    configurable: true,
-  })
-  const res = merge(x, y)
-  t.is(res.value, 42)
-  t.is(res.other, 33)
-  // @ts-ignore
-  t.is(res.xid, 1)
-  // @ts-ignore
-  t.is(res.yid, 2)
-  t.is(res[mySymbol], 'new')
-  t.is(Object.keys(res).length, 2)
-  t.true(Object.keys(res).includes('value'))
-  t.true(Object.keys(res).includes('other'))
-})
-
-test('readme', t => {
-  const starter = { name: 'Squirtle', types: { water: true } }
-  const newValues = { name: 'Wartortle', types: { fighting: true }, level: 16 }
-
-  const evolution = merge(starter, newValues, { is: 'cool' })
-
-  t.deepEqual(evolution, {
-    name: 'Wartortle',
-    types: { water: true, fighting: true },
-    level: 16,
-    is: 'cool',
-  })
-})