WIP - add extractor, generate snippet_data

node_modules/timm/lib/api.js.flow

@@ -0,0 +1,23 @@
+// @flow
+
+import timm from '../src/timm';  // this file will be used from <PROJECT>/lib
+
+declare export default typeof(timm);
+declare export var clone: typeof(timm.clone);
+declare export var addLast: typeof(timm.addLast);
+declare export var addFirst: typeof(timm.addFirst);
+declare export var removeLast: typeof(timm.removeLast);
+declare export var removeFirst: typeof(timm.removeFirst);
+declare export var insert: typeof(timm.insert);
+declare export var removeAt: typeof(timm.removeAt);
+declare export var replaceAt: typeof(timm.replaceAt);
+declare export var getIn: typeof(timm.getIn);
+declare export var set: typeof(timm.set);
+declare export var setIn: typeof(timm.setIn);
+declare export var update: typeof(timm.update);
+declare export var updateIn: typeof(timm.updateIn);
+declare export var merge: typeof(timm.merge);
+declare export var mergeDeep: typeof(timm.mergeDeep);
+declare export var mergeIn: typeof(timm.mergeIn);
+declare export var omit: typeof(timm.omit);
+declare export var addDefaults: typeof(timm.addDefaults);

node_modules/timm/lib/timm.d.ts

@@ -0,0 +1,76 @@
+declare module 'timm' {
+  type ArrayOrObject = Array<any> | Object;
+  type Key = number | string;
+
+  export function clone<T = ArrayOrObject>(obj: T): T;
+  export function addLast<T>(array: Array<T>, val: Array<T> | T): Array<T>;
+  export function addFirst<T>(array: Array<T>, val: Array<T> | T): Array<T>;
+  export function removeLast<T>(array: Array<T>): Array<T>;
+  export function removeFirst<T>(array: Array<T>): Array<T>;
+  export function insert<T>(
+    array: Array<T>,
+    idx: number,
+    val: Array<T> | T
+  ): Array<T>;
+  export function removeAt<T>(array: Array<T>, idx: number): Array<T>;
+  export function replaceAt<T>(
+    array: Array<T>,
+    idx: number,
+    newItem: T
+  ): Array<T>;
+  export function getIn(obj: ArrayOrObject | undefined, path: Array<Key>): any;
+  export function set<T>(obj: T | undefined, key: Key, val: any): T;
+  export function setIn<T = ArrayOrObject>(
+    obj: T,
+    path: Array<Key>,
+    val: any
+  ): T;
+  export function update<T = ArrayOrObject>(
+    obj: T,
+    key: Key,
+    fnUpdate: (prevValue: any) => any
+  ): T;
+  export function updateIn<T = ArrayOrObject>(
+    obj: T,
+    path: Array<Key>,
+    fnUpdate: (prevValue: any) => any
+  ): T;
+  export function merge(
+    a: Object,
+    b?: Object,
+    c?: Object,
+    d?: Object,
+    e?: Object,
+    f?: Object,
+    ...rest: Array<Object>
+  ): Object;
+  export function mergeDeep(
+    a: Object,
+    b?: Object,
+    c?: Object,
+    d?: Object,
+    e?: Object,
+    f?: Object,
+    ...rest: Array<Object>
+  ): Object;
+  export function mergeIn<T = ArrayOrObject>(
+    a: T,
+    path: Array<Key>,
+    b?: Object,
+    c?: Object,
+    d?: Object,
+    e?: Object,
+    f?: Object,
+    ...rest: Array<Object>
+  ): T;
+  export function omit(obj: Object, attrs: Array<string> | string): Object;
+  export function addDefaults(
+    a: Object,
+    b?: Object,
+    c?: Object,
+    d?: Object,
+    e?: Object,
+    f?: Object,
+    ...rest: Array<Object>
+  ): Object;
+}

node_modules/timm/lib/timm.js

@@ -0,0 +1,679 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clone = clone;
+exports.addLast = addLast;
+exports.addFirst = addFirst;
+exports.removeLast = removeLast;
+exports.removeFirst = removeFirst;
+exports.insert = insert;
+exports.removeAt = removeAt;
+exports.replaceAt = replaceAt;
+exports.getIn = getIn;
+exports.set = set;
+exports.setIn = setIn;
+exports.update = update;
+exports.updateIn = updateIn;
+exports.merge = merge;
+exports.mergeDeep = mergeDeep;
+exports.mergeIn = mergeIn;
+exports.omit = omit;
+exports.addDefaults = addDefaults;
+exports["default"] = void 0;
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+/*!
+ * Timm
+ *
+ * Immutability helpers with fast reads and acceptable writes.
+ *
+ * @copyright Guillermo Grau Panea 2016
+ * @license MIT
+ */
+var INVALID_ARGS = 'INVALID_ARGS'; // ===============================================
+// ### Helpers
+// ===============================================
+
+function throwStr(msg) {
+  throw new Error(msg);
+}
+
+function getKeysAndSymbols(obj) {
+  var keys = Object.keys(obj);
+
+  if (Object.getOwnPropertySymbols) {
+    return keys.concat(Object.getOwnPropertySymbols(obj));
+  }
+
+  return keys;
+}
+
+var hasOwnProperty = {}.hasOwnProperty;
+
+function clone(obj) {
+  if (Array.isArray(obj)) return obj.slice();
+  var keys = getKeysAndSymbols(obj);
+  var out = {};
+
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    out[key] = obj[key];
+  }
+
+  return out;
+}
+
+function doMerge(fAddDefaults, fDeep, first) {
+  var out = first;
+
+  if (!(out != null)) {
+    throwStr(process.env.NODE_ENV !== 'production' ? 'At least one object should be provided to merge()' : INVALID_ARGS);
+  }
+
+  var fChanged = false;
+
+  for (var idx = 0; idx < (arguments.length <= 3 ? 0 : arguments.length - 3); idx++) {
+    var obj = idx + 3 < 3 || arguments.length <= idx + 3 ? undefined : arguments[idx + 3];
+    if (obj == null) continue;
+    var keys = getKeysAndSymbols(obj);
+    if (!keys.length) continue;
+
+    for (var j = 0; j <= keys.length; j++) {
+      var key = keys[j];
+      if (fAddDefaults && out[key] !== undefined) continue;
+      var nextVal = obj[key];
+
+      if (fDeep && isObject(out[key]) && isObject(nextVal)) {
+        nextVal = doMerge(fAddDefaults, fDeep, out[key], nextVal);
+      }
+
+      if (nextVal === undefined || nextVal === out[key]) continue;
+
+      if (!fChanged) {
+        fChanged = true;
+        out = clone(out);
+      }
+
+      out[key] = nextVal;
+    }
+  }
+
+  return out;
+}
+
+function isObject(o) {
+  var type = _typeof(o);
+
+  return o != null && type === 'object';
+} // _deepFreeze = (obj) ->
+//   Object.freeze obj
+//   for key in Object.getOwnPropertyNames obj
+//     val = obj[key]
+//     if isObject(val) and not Object.isFrozen val
+//       _deepFreeze val
+//   obj
+// ===============================================
+// -- ### Arrays
+// ===============================================
+// -- #### addLast()
+// -- Returns a new array with an appended item or items.
+// --
+// -- Usage: `addLast<T>(array: Array<T>, val: Array<T>|T): Array<T>`
+// --
+// -- ```js
+// -- arr = ['a', 'b']
+// -- arr2 = addLast(arr, 'c')
+// -- // ['a', 'b', 'c']
+// -- arr2 === arr
+// -- // false
+// -- arr3 = addLast(arr, ['c', 'd'])
+// -- // ['a', 'b', 'c', 'd']
+// -- ```
+// `array.concat(val)` also handles the scalar case,
+// but is apparently very slow
+
+
+function addLast(array, val) {
+  if (Array.isArray(val)) return array.concat(val);
+  return array.concat([val]);
+} // -- #### addFirst()
+// -- Returns a new array with a prepended item or items.
+// --
+// -- Usage: `addFirst<T>(array: Array<T>, val: Array<T>|T): Array<T>`
+// --
+// -- ```js
+// -- arr = ['a', 'b']
+// -- arr2 = addFirst(arr, 'c')
+// -- // ['c', 'a', 'b']
+// -- arr2 === arr
+// -- // false
+// -- arr3 = addFirst(arr, ['c', 'd'])
+// -- // ['c', 'd', 'a', 'b']
+// -- ```
+
+
+function addFirst(array, val) {
+  if (Array.isArray(val)) return val.concat(array);
+  return [val].concat(array);
+} // -- #### removeLast()
+// -- Returns a new array removing the last item.
+// --
+// -- Usage: `removeLast<T>(array: Array<T>): Array<T>`
+// --
+// -- ```js
+// -- arr = ['a', 'b']
+// -- arr2 = removeLast(arr)
+// -- // ['a']
+// -- arr2 === arr
+// -- // false
+// --
+// -- // The same array is returned if there are no changes:
+// -- arr3 = []
+// -- removeLast(arr3) === arr3
+// -- // true
+// -- ```
+
+
+function removeLast(array) {
+  if (!array.length) return array;
+  return array.slice(0, array.length - 1);
+} // -- #### removeFirst()
+// -- Returns a new array removing the first item.
+// --
+// -- Usage: `removeFirst<T>(array: Array<T>): Array<T>`
+// --
+// -- ```js
+// -- arr = ['a', 'b']
+// -- arr2 = removeFirst(arr)
+// -- // ['b']
+// -- arr2 === arr
+// -- // false
+// --
+// -- // The same array is returned if there are no changes:
+// -- arr3 = []
+// -- removeFirst(arr3) === arr3
+// -- // true
+// -- ```
+
+
+function removeFirst(array) {
+  if (!array.length) return array;
+  return array.slice(1);
+} // -- #### insert()
+// -- Returns a new array obtained by inserting an item or items
+// -- at a specified index.
+// --
+// -- Usage: `insert<T>(array: Array<T>, idx: number, val: Array<T>|T): Array<T>`
+// --
+// -- ```js
+// -- arr = ['a', 'b', 'c']
+// -- arr2 = insert(arr, 1, 'd')
+// -- // ['a', 'd', 'b', 'c']
+// -- arr2 === arr
+// -- // false
+// -- insert(arr, 1, ['d', 'e'])
+// -- // ['a', 'd', 'e', 'b', 'c']
+// -- ```
+
+
+function insert(array, idx, val) {
+  return array.slice(0, idx).concat(Array.isArray(val) ? val : [val]).concat(array.slice(idx));
+} // -- #### removeAt()
+// -- Returns a new array obtained by removing an item at
+// -- a specified index.
+// --
+// -- Usage: `removeAt<T>(array: Array<T>, idx: number): Array<T>`
+// --
+// -- ```js
+// -- arr = ['a', 'b', 'c']
+// -- arr2 = removeAt(arr, 1)
+// -- // ['a', 'c']
+// -- arr2 === arr
+// -- // false
+// --
+// -- // The same array is returned if there are no changes:
+// -- removeAt(arr, 4) === arr
+// -- // true
+// -- ```
+
+
+function removeAt(array, idx) {
+  if (idx >= array.length || idx < 0) return array;
+  return array.slice(0, idx).concat(array.slice(idx + 1));
+} // -- #### replaceAt()
+// -- Returns a new array obtained by replacing an item at
+// -- a specified index. If the provided item is the same as
+// -- (*referentially equal to*) the previous item at that position,
+// -- the original array is returned.
+// --
+// -- Usage: `replaceAt<T>(array: Array<T>, idx: number, newItem: T): Array<T>`
+// --
+// -- ```js
+// -- arr = ['a', 'b', 'c']
+// -- arr2 = replaceAt(arr, 1, 'd')
+// -- // ['a', 'd', 'c']
+// -- arr2 === arr
+// -- // false
+// --
+// -- // The same object is returned if there are no changes:
+// -- replaceAt(arr, 1, 'b') === arr
+// -- // true
+// -- ```
+
+
+function replaceAt(array, idx, newItem) {
+  if (array[idx] === newItem) return array;
+  var len = array.length;
+  var result = Array(len);
+
+  for (var i = 0; i < len; i++) {
+    result[i] = array[i];
+  }
+
+  result[idx] = newItem;
+  return result;
+} // ===============================================
+// -- ### Collections (objects and arrays)
+// ===============================================
+// -- The following types are used throughout this section
+// -- ```js
+// -- type ArrayOrObject = Array<any>|Object;
+// -- type Key = number|string;
+// -- ```
+// -- #### getIn()
+// -- Returns a value from an object at a given path. Works with
+// -- nested arrays and objects. If the path does not exist, it returns
+// -- `undefined`.
+// --
+// -- Usage: `getIn(obj: ?ArrayOrObject, path: Array<Key>): any`
+// --
+// -- ```js
+// -- obj = { a: 1, b: 2, d: { d1: 3, d2: 4 }, e: ['a', 'b', 'c'] }
+// -- getIn(obj, ['d', 'd1'])
+// -- // 3
+// -- getIn(obj, ['e', 1])
+// -- // 'b'
+// -- ```
+
+
+function getIn(obj, path) {
+  if (!Array.isArray(path)) {
+    throwStr(process.env.NODE_ENV !== 'production' ? 'A path array should be provided when calling getIn()' : INVALID_ARGS);
+  }
+
+  if (obj == null) return undefined;
+  var ptr = obj;
+
+  for (var i = 0; i < path.length; i++) {
+    var key = path[i];
+    ptr = ptr != null ? ptr[key] : undefined;
+    if (ptr === undefined) return ptr;
+  }
+
+  return ptr;
+} // -- #### set()
+// -- Returns a new object with a modified attribute.
+// -- If the provided value is the same as (*referentially equal to*)
+// -- the previous value, the original object is returned.
+// --
+// -- Usage: `set<T>(obj: ?T, key: Key, val: any): T`
+// --
+// -- ```js
+// -- obj = { a: 1, b: 2, c: 3 }
+// -- obj2 = set(obj, 'b', 5)
+// -- // { a: 1, b: 5, c: 3 }
+// -- obj2 === obj
+// -- // false
+// --
+// -- // The same object is returned if there are no changes:
+// -- set(obj, 'b', 2) === obj
+// -- // true
+// -- ```
+
+
+function set(obj, key, val) {
+  var fallback = typeof key === 'number' ? [] : {};
+  var finalObj = obj == null ? fallback : obj;
+  if (finalObj[key] === val) return finalObj;
+  var obj2 = clone(finalObj);
+  obj2[key] = val;
+  return obj2;
+} // -- #### setIn()
+// -- Returns a new object with a modified **nested** attribute.
+// --
+// -- Notes:
+// --
+// -- * If the provided value is the same as (*referentially equal to*)
+// -- the previous value, the original object is returned.
+// -- * If the path does not exist, it will be created before setting
+// -- the new value.
+// --
+// -- Usage: `setIn<T: ArrayOrObject>(obj: T, path: Array<Key>, val: any): T`
+// --
+// -- ```js
+// -- obj = { a: 1, b: 2, d: { d1: 3, d2: 4 }, e: { e1: 'foo', e2: 'bar' } }
+// -- obj2 = setIn(obj, ['d', 'd1'], 4)
+// -- // { a: 1, b: 2, d: { d1: 4, d2: 4 }, e: { e1: 'foo', e2: 'bar' } }
+// -- obj2 === obj
+// -- // false
+// -- obj2.d === obj.d
+// -- // false
+// -- obj2.e === obj.e
+// -- // true
+// --
+// -- // The same object is returned if there are no changes:
+// -- obj3 = setIn(obj, ['d', 'd1'], 3)
+// -- // { a: 1, b: 2, d: { d1: 3, d2: 4 }, e: { e1: 'foo', e2: 'bar' } }
+// -- obj3 === obj
+// -- // true
+// -- obj3.d === obj.d
+// -- // true
+// -- obj3.e === obj.e
+// -- // true
+// --
+// -- // ... unknown paths create intermediate keys. Numeric segments are treated as array indices:
+// -- setIn({ a: 3 }, ['unknown', 0, 'path'], 4)
+// -- // { a: 3, unknown: [{ path: 4 }] }
+// -- ```
+
+
+function doSetIn(obj, path, val, idx) {
+  var newValue;
+  var key = path[idx];
+
+  if (idx === path.length - 1) {
+    newValue = val;
+  } else {
+    var nestedObj = isObject(obj) && isObject(obj[key]) ? obj[key] : typeof path[idx + 1] === 'number' ? [] : {};
+    newValue = doSetIn(nestedObj, path, val, idx + 1);
+  }
+
+  return set(obj, key, newValue);
+}
+
+function setIn(obj, path, val) {
+  if (!path.length) return val;
+  return doSetIn(obj, path, val, 0);
+} // -- #### update()
+// -- Returns a new object with a modified attribute,
+// -- calculated via a user-provided callback based on the current value.
+// -- If the calculated value is the same as (*referentially equal to*)
+// -- the previous value, the original object is returned.
+// --
+// -- Usage: `update<T: ArrayOrObject>(obj: T, key: Key,
+// -- fnUpdate: (prevValue: any) => any): T`
+// --
+// -- ```js
+// -- obj = { a: 1, b: 2, c: 3 }
+// -- obj2 = update(obj, 'b', (val) => val + 1)
+// -- // { a: 1, b: 3, c: 3 }
+// -- obj2 === obj
+// -- // false
+// --
+// -- // The same object is returned if there are no changes:
+// -- update(obj, 'b', (val) => val) === obj
+// -- // true
+// -- ```
+
+
+function update(obj, key, fnUpdate) {
+  var prevVal = obj == null ? undefined : obj[key];
+  var nextVal = fnUpdate(prevVal);
+  return set(obj, key, nextVal);
+} // -- #### updateIn()
+// -- Returns a new object with a modified **nested** attribute,
+// -- calculated via a user-provided callback based on the current value.
+// -- If the calculated value is the same as (*referentially equal to*)
+// -- the previous value, the original object is returned.
+// --
+// -- Usage: `updateIn<T: ArrayOrObject>(obj: T, path: Array<Key>,
+// -- fnUpdate: (prevValue: any) => any): T`
+// --
+// -- ```js
+// -- obj = { a: 1, d: { d1: 3, d2: 4 } }
+// -- obj2 = updateIn(obj, ['d', 'd1'], (val) => val + 1)
+// -- // { a: 1, d: { d1: 4, d2: 4 } }
+// -- obj2 === obj
+// -- // false
+// --
+// -- // The same object is returned if there are no changes:
+// -- obj3 = updateIn(obj, ['d', 'd1'], (val) => val)
+// -- // { a: 1, d: { d1: 3, d2: 4 } }
+// -- obj3 === obj
+// -- // true
+// -- ```
+
+
+function updateIn(obj, path, fnUpdate) {
+  var prevVal = getIn(obj, path);
+  var nextVal = fnUpdate(prevVal);
+  return setIn(obj, path, nextVal);
+} // -- #### merge()
+// -- Returns a new object built as follows: the overlapping keys from the
+// -- second one overwrite the corresponding entries from the first one.
+// -- Similar to `Object.assign()`, but immutable.
+// --
+// -- Usage:
+// --
+// -- * `merge(obj1: Object, obj2: ?Object): Object`
+// -- * `merge(obj1: Object, ...objects: Array<?Object>): Object`
+// --
+// -- The unmodified `obj1` is returned if `obj2` does not *provide something
+// -- new to* `obj1`, i.e. if either of the following
+// -- conditions are true:
+// --
+// -- * `obj2` is `null` or `undefined`
+// -- * `obj2` is an object, but it is empty
+// -- * All attributes of `obj2` are `undefined`
+// -- * All attributes of `obj2` are referentially equal to the
+// --   corresponding attributes of `obj1`
+// --
+// -- Note that `undefined` attributes in `obj2` do not modify the
+// -- corresponding attributes in `obj1`.
+// --
+// -- ```js
+// -- obj1 = { a: 1, b: 2, c: 3 }
+// -- obj2 = { c: 4, d: 5 }
+// -- obj3 = merge(obj1, obj2)
+// -- // { a: 1, b: 2, c: 4, d: 5 }
+// -- obj3 === obj1
+// -- // false
+// --
+// -- // The same object is returned if there are no changes:
+// -- merge(obj1, { c: 3 }) === obj1
+// -- // true
+// -- ```
+
+
+function merge(a, b, c, d, e, f) {
+  for (var _len = arguments.length, rest = new Array(_len > 6 ? _len - 6 : 0), _key = 6; _key < _len; _key++) {
+    rest[_key - 6] = arguments[_key];
+  }
+
+  return rest.length ? doMerge.call.apply(doMerge, [null, false, false, a, b, c, d, e, f].concat(rest)) : doMerge(false, false, a, b, c, d, e, f);
+} // -- #### mergeDeep()
+// -- Returns a new object built as follows: the overlapping keys from the
+// -- second one overwrite the corresponding entries from the first one.
+// -- If both the first and second entries are objects they are merged recursively.
+// -- Similar to `Object.assign()`, but immutable, and deeply merging.
+// --
+// -- Usage:
+// --
+// -- * `mergeDeep(obj1: Object, obj2: ?Object): Object`
+// -- * `mergeDeep(obj1: Object, ...objects: Array<?Object>): Object`
+// --
+// -- The unmodified `obj1` is returned if `obj2` does not *provide something
+// -- new to* `obj1`, i.e. if either of the following
+// -- conditions are true:
+// --
+// -- * `obj2` is `null` or `undefined`
+// -- * `obj2` is an object, but it is empty
+// -- * All attributes of `obj2` are `undefined`
+// -- * All attributes of `obj2` are referentially equal to the
+// --   corresponding attributes of `obj1`
+// --
+// -- Note that `undefined` attributes in `obj2` do not modify the
+// -- corresponding attributes in `obj1`.
+// --
+// -- ```js
+// -- obj1 = { a: 1, b: 2, c: { a: 1 } }
+// -- obj2 = { b: 3, c: { b: 2 } }
+// -- obj3 = mergeDeep(obj1, obj2)
+// -- // { a: 1, b: 3, c: { a: 1, b: 2 }  }
+// -- obj3 === obj1
+// -- // false
+// --
+// -- // The same object is returned if there are no changes:
+// -- mergeDeep(obj1, { c: { a: 1 } }) === obj1
+// -- // true
+// -- ```
+
+
+function mergeDeep(a, b, c, d, e, f) {
+  for (var _len2 = arguments.length, rest = new Array(_len2 > 6 ? _len2 - 6 : 0), _key2 = 6; _key2 < _len2; _key2++) {
+    rest[_key2 - 6] = arguments[_key2];
+  }
+
+  return rest.length ? doMerge.call.apply(doMerge, [null, false, true, a, b, c, d, e, f].concat(rest)) : doMerge(false, true, a, b, c, d, e, f);
+} // -- #### mergeIn()
+// -- Similar to `merge()`, but merging the value at a given nested path.
+// -- Note that the returned type is the same as that of the first argument.
+// --
+// -- Usage:
+// --
+// -- * `mergeIn<T: ArrayOrObject>(obj1: T, path: Array<Key>, obj2: ?Object): T`
+// -- * `mergeIn<T: ArrayOrObject>(obj1: T, path: Array<Key>,
+// -- ...objects: Array<?Object>): T`
+// --
+// -- ```js
+// -- obj1 = { a: 1, d: { b: { d1: 3, d2: 4 } } }
+// -- obj2 = { d3: 5 }
+// -- obj3 = mergeIn(obj1, ['d', 'b'], obj2)
+// -- // { a: 1, d: { b: { d1: 3, d2: 4, d3: 5 } } }
+// -- obj3 === obj1
+// -- // false
+// --
+// -- // The same object is returned if there are no changes:
+// -- mergeIn(obj1, ['d', 'b'], { d2: 4 }) === obj1
+// -- // true
+// -- ```
+
+
+function mergeIn(a, path, b, c, d, e, f) {
+  var prevVal = getIn(a, path);
+  if (prevVal == null) prevVal = {};
+  var nextVal;
+
+  for (var _len3 = arguments.length, rest = new Array(_len3 > 7 ? _len3 - 7 : 0), _key3 = 7; _key3 < _len3; _key3++) {
+    rest[_key3 - 7] = arguments[_key3];
+  }
+
+  if (rest.length) {
+    nextVal = doMerge.call.apply(doMerge, [null, false, false, prevVal, b, c, d, e, f].concat(rest));
+  } else {
+    nextVal = doMerge(false, false, prevVal, b, c, d, e, f);
+  }
+
+  return setIn(a, path, nextVal);
+} // -- #### omit()
+// -- Returns an object excluding one or several attributes.
+// --
+// -- Usage: `omit(obj: Object, attrs: Array<string>|string): Object`
+//
+// -- ```js
+// -- obj = { a: 1, b: 2, c: 3, d: 4 }
+// -- omit(obj, 'a')
+// -- // { b: 2, c: 3, d: 4 }
+// -- omit(obj, ['b', 'c'])
+// -- // { a: 1, d: 4 }
+// --
+// -- // The same object is returned if there are no changes:
+// -- omit(obj, 'z') === obj1
+// -- // true
+// -- ```
+
+
+function omit(obj, attrs) {
+  var omitList = Array.isArray(attrs) ? attrs : [attrs];
+  var fDoSomething = false;
+
+  for (var i = 0; i < omitList.length; i++) {
+    if (hasOwnProperty.call(obj, omitList[i])) {
+      fDoSomething = true;
+      break;
+    }
+  }
+
+  if (!fDoSomething) return obj;
+  var out = {};
+  var keys = getKeysAndSymbols(obj);
+
+  for (var _i = 0; _i < keys.length; _i++) {
+    var key = keys[_i];
+    if (omitList.indexOf(key) >= 0) continue;
+    out[key] = obj[key];
+  }
+
+  return out;
+} // -- #### addDefaults()
+// -- Returns a new object built as follows: `undefined` keys in the first one
+// -- are filled in with the corresponding values from the second one
+// -- (even if they are `null`).
+// --
+// -- Usage:
+// --
+// -- * `addDefaults(obj: Object, defaults: Object): Object`
+// -- * `addDefaults(obj: Object, ...defaultObjects: Array<?Object>): Object`
+// --
+// -- ```js
+// -- obj1 = { a: 1, b: 2, c: 3 }
+// -- obj2 = { c: 4, d: 5, e: null }
+// -- obj3 = addDefaults(obj1, obj2)
+// -- // { a: 1, b: 2, c: 3, d: 5, e: null }
+// -- obj3 === obj1
+// -- // false
+// --
+// -- // The same object is returned if there are no changes:
+// -- addDefaults(obj1, { c: 4 }) === obj1
+// -- // true
+// -- ```
+
+
+function addDefaults(a, b, c, d, e, f) {
+  for (var _len4 = arguments.length, rest = new Array(_len4 > 6 ? _len4 - 6 : 0), _key4 = 6; _key4 < _len4; _key4++) {
+    rest[_key4 - 6] = arguments[_key4];
+  }
+
+  return rest.length ? doMerge.call.apply(doMerge, [null, true, false, a, b, c, d, e, f].concat(rest)) : doMerge(true, false, a, b, c, d, e, f);
+} // ===============================================
+// ### Public API
+// ===============================================
+
+
+var timm = {
+  clone: clone,
+  addLast: addLast,
+  addFirst: addFirst,
+  removeLast: removeLast,
+  removeFirst: removeFirst,
+  insert: insert,
+  removeAt: removeAt,
+  replaceAt: replaceAt,
+  getIn: getIn,
+  // eslint-disable-next-line object-shorthand
+  set: set,
+  // so that flow doesn't complain
+  setIn: setIn,
+  update: update,
+  updateIn: updateIn,
+  merge: merge,
+  mergeDeep: mergeDeep,
+  mergeIn: mergeIn,
+  omit: omit,
+  addDefaults: addDefaults
+};
+var _default = timm;
+exports["default"] = _default;