rescape-ramda/lib/functions-b6202a08.js

'use strict';

var R = require('ramda');
var Result = require('folktale/result');
var Rm = require('ramda-maybe');

function _typeof(obj) {
  "@babel/helpers - typeof";

  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
    _typeof = function (obj) {
      return typeof obj;
    };
  } else {
    _typeof = function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
  }

  return _typeof(obj);
}

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

function _setPrototypeOf(o, p) {
  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };

  return _setPrototypeOf(o, p);
}

function isNativeReflectConstruct() {
  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
  if (Reflect.construct.sham) return false;
  if (typeof Proxy === "function") return true;

  try {
    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
    return true;
  } catch (e) {
    return false;
  }
}

function _construct(Parent, args, Class) {
  if (isNativeReflectConstruct()) {
    _construct = Reflect.construct;
  } else {
    _construct = function _construct(Parent, args, Class) {
      var a = [null];
      a.push.apply(a, args);
      var Constructor = Function.bind.apply(Parent, a);
      var instance = new Constructor();
      if (Class) _setPrototypeOf(instance, Class.prototype);
      return instance;
    };
  }

  return _construct.apply(null, arguments);
}

function _slicedToArray(arr, i) {
  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
}

function _toArray(arr) {
  return _arrayWithHoles(arr) || _iterableToArray(arr) || _nonIterableRest();
}

function _toConsumableArray(arr) {
  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
}

function _arrayWithoutHoles(arr) {
  if (Array.isArray(arr)) {
    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];

    return arr2;
  }
}

function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}

function _iterableToArray(iter) {
  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
}

function _iterableToArrayLimit(arr, i) {
  if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) {
    return;
  }

  var _arr = [];
  var _n = true;
  var _d = false;
  var _e = undefined;

  try {
    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
      _arr.push(_s.value);

      if (i && _arr.length === i) break;
    }
  } catch (err) {
    _d = true;
    _e = err;
  } finally {
    try {
      if (!_n && _i["return"] != null) _i["return"]();
    } finally {
      if (_d) throw _e;
    }
  }

  return _arr;
}

function _nonIterableSpread() {
  throw new TypeError("Invalid attempt to spread non-iterable instance");
}

function _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance");
}

var regexToMatchARegex = /\/((?![*+?])(?:[^\r\n\[/\\]|\\.|\[(?:[^\r\n\]\\]|\\.)*\])+)\/((?:g(?:im?|mi?)?|i(?:gm?|mg?)?|m(?:gi?|ig?)?)?)/;
/**
 * We use this instead of isObject since it's possible to have something that is an object without
 * a prototype to make it an object type
 * @param {*} obj value to test
 * @return {boolean} True if R.is(Object, obj) or is not null and it a typeof 'object'
 */

var isObject = function isObject(obj) {
  return R.is(Object, obj) || obj !== null && _typeof(obj) === 'object';
};
/**
 * Return an empty string if the given entity is falsy
 * @param {Object} entity The entity to check
 * @returns {String|Object} The empty string or the Object
 * @sig orEmpty:: a -> a
 *        :: a -> String
 */

var orEmpty = function orEmpty(entity) {
  return entity || '';
};
/**
 * Removed null or undefined items from an iterable
 * @param [a] items Items that might have falsy values to remove
 * @returns The compacted items
 * @sig compact:: [a] -> [a]
 * @sig compact:: {k,v} -> {k,v}
 */

var compact = R.reject(R.isNil);
/**
 * Remove empty strings
 * @param [a] items Items that might have empty or null strings to remove
 * @returns The compacted items
 * @sig compactEmpty:: [a] -> [a]
 */

var compactEmpty = R.reject(R.either(R.isNil, R.isEmpty));
/**
 * Convert an empty value to null
 * @param a item Item that might be empty according to isEmpty
 * @returns the
 * @sig emptyToNull:: a -> a
 *            :: a -> null
 */

var emptyToNull = R.when(R.isEmpty, function () {
  return null;
});
/**
 * Join elements, first remove null items and empty strings. If the result is empty make it null
 * @param connector Join connector string
 * @param [a] items Items to join that might be removed
 * @sig compactEmpty:: [a] -> String
 *             :: [a] -> null
 */

var compactJoin = R.compose(function (connector, items) {
  return R.pipe(compactEmpty, R.join(connector), emptyToNull)(items);
});
/**
 * Creates a partial mapping function that expects an iterable and maps each item of the iterable to the given property
 * @param {String} prop The prop of each object to map
 * @param {[Object]} items The objects to map
 * @returns {[Object]} The mapped objects
 * @sig mapProp :: String -> [{k, v}] -> [a]
 */

var mapProp = R.curry(function (prop, objs) {
  return R.pipe(R.prop, R.map)(prop)(objs);
});
/**
 * Creates a partial function that maps an array of objects to an object keyed by the given prop of the object's
 * of the array, valued by the item. If the item is not an array, it leaves it alone, assuming it is already indexed
 * @param {String} prop The prop of each object to use as the key
 * @param {[Object]} items The items to map
 * @returns {Object} The returned object
 * @sig mapPropValueAsIndex:: String -> [{k, v}] -> {j, {k, v}}
 * @sig mapPropValueAsIndex:: String -> {k, v} -> {k, v}
 */

var mapPropValueAsIndex = R.curry(function (prop, obj) {
  return R.when(Array.isArray, R.pipe(R.prop, R.indexBy)(prop))(obj);
});
/**
 * Merges a list of objects by the given key and returns the values, meaning all items that are
 * duplicate prop key value are removed from the final list
 * @returns {[Object]} The items without the duplicates
 * @sig removeDuplicateObjectsByProp:: String -> [{k, v}] -> [{k, v}]
 */

var removeDuplicateObjectsByProp = R.curry(function (prop, list) {
  return R.pipe(mapPropValueAsIndex(prop), R.values)(list);
});
/**
 * Returns the id of the given value if it is an object or the value itself if it is not.
 * @param {Object|String|Number} objOrId
 * @returns {String|Number} an id
 * @sig idOrIdFromObj:: a -> a
 *              :: {k, v} -> a
 */

var idOrIdFromObj = R.when(function (objOrId) {
  return _typeof(objOrId) === 'object' && objOrId !== null;
}, R.prop('id'));
/**
 * Deep merge values that are objects but not arrays
 * based on https://github.com/ramda/ramda/pull/1088
 * @params {Object} l the 'left' side object to merge
 * @params {Object} r the 'right' side object to merge
 * @type {Immutable.Map<string, V>|__Cursor.Cursor|List<T>|Map<K, V>|*}
 * @returns {Object} The deep-merged object
 * @sig mergeDeep:: (<k, v>, <k, v>) -> <k, v>
 */

var mergeDeep = R.mergeWith(function (l, r) {
  // If either (hopefully both) items are arrays or not both objects
  // accept the right value
  return (// If either is a function take the last
    R.is(Function, l) || R.is(Function, r) || // If either is an array take the last
    l && l.concat && Array.isArray(l) || r && r.concat && Array.isArray(r) || !(R.is(Object, l) && R.is(Object, r)) ? r : mergeDeep(l, r)
  ); // tail recursive
});
/**
 * mergeDeep any number of objects
 * @params {[Object]} objs Array of objects to reduce
 * @returns {Object} The deep-merged objects
 */

var mergeDeepAll = R.reduce(mergeDeep, {});
/**
 * Deep merge values with a custom function that are objects
 * based on https://github.com/ramda/ramda/pull/1088
 * @params {Function} fn The merge function left l, right r:: l -> r -> a
 * @params {Object} left the 'left' side object to merge
 * @params {Object} right the 'right' side object to morge
 * @returns {Object} The deep-merged objeck
 * @sig mergeDeep:: (<k, v>, <k, v>) -> <k, v>
 */

var mergeDeepWith = R.curry(function (fn, left, right) {
  return R.mergeWith(function (l, r) {
    // If either (hopefully both) items are arrays or not both objects
    // accept the right value
    return l && l.concat && Array.isArray(l) || r && r.concat && Array.isArray(r) || !R.all(isObject)([l, r]) || R.any(R.is(Function))([l, r]) ? fn(l, r) : mergeDeepWith(fn, l, r); // tail recursive
  })(left, right);
});
/**
 * Merge Deep that concats arrays of matching keys
 * @params {Object} left the 'left' side object to merge
 * @params {Object} right the 'right' side object to morge
 * @returns {Object} The deep-merged object
 * @sig mergeDeep:: (<k, v>, <k, v>) -> <k, v>
 */

var mergeDeepWithConcatArrays = R.curry(function (left, right) {
  return mergeDeepWith(function (l, r) {
    return R.cond([[R.all(R.allPass([R.identity, R.prop('concat'), Array.isArray])), R.apply(R.concat)], [R.complement(R.all)(isObject), R.last], [R.T, R.apply(mergeDeepWithConcatArrays)] // tail recursive
    ])([l, r]);
  })(left, right);
});
/**
 * Merge Deep and also apply the given function to array items with the same index
 * @params {Function} fn The merge function left l, right r, string k:: l -> r -> k -> a
 * @params {Object} left the 'left' side object to merge
 * @params {Object} right the 'right' side object to morge
 * @returns {Object} The deep-merged object
 * @sig mergeDeepWithRecurseArrayItems:: (<k, v>, <k, v>, k) -> <k, v>
 */

var mergeDeepWithRecurseArrayItems = R.curry(function (fn, left, right) {
  return R.cond([// Arrays
  [R.all(R.allPass([R.identity, R.prop('concat'), Array.isArray])), function (_ref) {
    var _ref2 = _slicedToArray(_ref, 2),
        l = _ref2[0],
        r = _ref2[1];

    return R.zipWith(function (a, b) {
      return mergeDeepWithRecurseArrayItems(fn, a, b);
    }, l, r);
  }], // Primitives
  [R.complement(R.all)(isObject), function (_ref3) {
    var _ref4 = _slicedToArray(_ref3, 2),
        l = _ref4[0],
        r = _ref4[1];

    return fn(l, r);
  }], // Objects
  [R.T, function (_ref5) {
    var _ref6 = _slicedToArray(_ref5, 2),
        l = _ref6[0],
        r = _ref6[1];

    return R.mergeWith(mergeDeepWithRecurseArrayItems(fn), l, r);
  }]])([left, right]);
});
/**
 * Like mergeDeepWithRecurseArrayItems but merges array items with a function itemMatchBy that determines
 * if an item from each array of left and right represents the same objects. The right object's array
 * items are returned but any left object item matching by itemMatchBy is deep merged with the matching right item.
 * There is no merge function for primitives, r is always returned
 * @params {Function} fn The item matching function, Arrays deep items in left and right. Called with the
 * item and current key/index
 * are merged. For example
 *   item => R.when(isObject, R.propOr(v, 'id'))(item)
 * would match on id if item is an object and has an id
 * @params {Object} left the 'left' side object to merge
 * @params {Object} right the 'right' side object to merge
 * @params {String} [key] Optional key or index of the parent object/array item
 * @returns {Object} The deep-merged object
 */

var mergeDeepWithRecurseArrayItemsByRight = R.curry(function (itemMatchBy, left, right) {
  return _mergeDeepWithRecurseArrayItemsByRight(itemMatchBy, null, left, right, null);
});
/**
 * Like mergeDeepWithRecurseArrayItemsByRight but takes mergeObject to merge objects, rather than just taking the
 * right value. Primitives still resolve to the right value. the mergeObject function should handle internal array
 * merging by recursing on this function or similar
 * @params {Function} fn The item matching function, Arrays deep items in left and right. Called with the
 * item and current key/index
 * are merged. For example
 * item => R.when(isObject, R.propOr(v, 'id'))(item)
 * would match on id if item is an object and has an id
 * @params {Function} itemMatchBy Expects the left and right object that need to be merged
 * @params {Function} mergeObject Expects left and right when they are objects. mergeObject typically recurses
 * with mergeDeepWithRecurseArrayItemsByAndMergeObjectByRight on each item of left and right after doing something
 * special. This function was designed with the idea of being used in Apollo InMemory Cache Type Policy merge functions
 * to continue calling Apollowing merge function on objects, which in tern delegates back to this function
 * @params {Object} left the 'left' side object to merge
 * @params {Object} right the 'right' side object to merge
 * @params {String} [key] Optional key or index of the parent object/array item
 * @returns {Object} The deep-merged object
 */

var mergeDeepWithRecurseArrayItemsByAndMergeObjectByRight = R.curry(function (itemMatchBy, mergeObject, left, right) {
  return _mergeDeepWithRecurseArrayItemsByRight(itemMatchBy, mergeObject, left, right, null);
});
var _mergeDeepWithRecurseArrayItemsByRight = function _mergeDeepWithRecurseArrayItemsByRight(itemMatchBy, mergeObject, left, right, key) {
  return R.cond([// Arrays
  [function (_ref7) {
    var _ref8 = _slicedToArray(_ref7, 2),
        l = _ref8[0],
        r = _ref8[1];

    return R.any(R.allPass([R.identity, R.prop('concat'), Array.isArray]))([l, r]);
  }, function (_ref9) {
    var _ref10 = _slicedToArray(_ref9, 2),
        l = _ref10[0],
        r = _ref10[1];

    // Null case, return the only array
    if (!l || !r) {
      return l || r;
    } // Create a lookup of l items


    var lItemsByValue = R.indexBy(function (li) {
      return itemMatchBy(li, key);
    }, l || []); // Map each item of r

    return R.addIndex(R.map)(function (rItem, i) {
      // If the lookup of the r item matches one of l items' itemMatchBy value,
      // recurse with both items. Else just return r
      var rItemValue = itemMatchBy(rItem, key);
      var hasMatchingLItem = R.has(rItemValue, lItemsByValue);
      return R.when(function () {
        return hasMatchingLItem;
      }, function () {
        // Pass the index as a key
        return _mergeDeepWithRecurseArrayItemsByRight(itemMatchBy, mergeObject, R.prop(rItemValue, lItemsByValue), rItem, i);
      })(rItem);
    }, r || []);
  }], // Primitives. If either is an object skip, it means 1 is null
  [R.none(isObject), function (_ref11) {
    var _ref12 = _slicedToArray(_ref11, 2),
        l = _ref12[0],
        r = _ref12[1];

    return r;
  }], // Objects and nulls
  [R.T, function (_ref13) {
    var _ref14 = _slicedToArray(_ref13, 2),
        l = _ref14[0],
        r = _ref14[1];

    return mergeObject ? mergeObject(l, r) : R.mergeWithKey(function (kk, ll, rr) {
      return _mergeDeepWithRecurseArrayItemsByRight(itemMatchBy, mergeObject, ll, rr, kk);
    }, l || {}, r || {});
  }]])([left, right]);
};
/**
 * mergeDeepWithRecurseArrayItems but passes obj as left and right so fn is called on every key
 * @params {Function} fn The merge function left l, right r, string k:: l -> r -> k -> a
 * @params {Object} left the 'left' side object to merge
 * @params {Object} right the 'right' side object to morge
 * @returns {Object} The deep-merged object
 * @sig mergeDeepWithRecurseArrayItems:: (<k, v>, <k, v>, k) -> <k, v>
 */

var applyDeep = R.curry(function (fn, obj) {
  return mergeDeepWithRecurseArrayItems(fn, obj, obj);
});
/**
 * Merge Deep and also apply the given function to array items with the same index.
 * This adds another function that maps the object results to something else after the objects are recursed upon
 * @params {Function} fn The merge function left l, right r, string k:: l -> r -> k -> a
 * @params {Function} applyObj Function called with the current key and the result of each recursion that is an object.
 * @params {Object} left the 'left' side object to merge
 * @params {Object} right the 'right' side object to morge
 * @returns {Object} The deep-merged object
 * @sig mergeDeepWithRecurseArrayItems:: (<k, v>, <k, v>, k) -> <k, v>
 */

var mergeDeepWithRecurseArrayItemsAndMapObjs = R.curry(function (fn, applyObj, left, right) {
  return _mergeDeepWithRecurseArrayItemsAndMapObjs(fn, applyObj, null, left, right);
});
/**
 * Same as mergeDeepWithRecurseArrayItemsAndMapObjs but sends the same left and right value so fn is called on every key
 * of ob * @params {Function} fn The merge function left l, right r, string k:: l -> r -> k -> a
 * @params {Function} applyObj Function called with the current key and the result of each recursion that is an object.
 * @params {Object} left the 'left' side object to merge
 * @params {Object} right the 'right' side object to morge
 * @returns {Object} The deep-merged object
 * @sig applyDeepAndMapObjs:: (<k, v>, <k, v>, k) -> <k, v>j
 */

var applyDeepAndMapObjs = R.curry(function (fn, applyObj, obj) {
  return mergeDeepWithRecurseArrayItemsAndMapObjs(fn, applyObj, obj, obj);
});

var _mergeDeepWithRecurseArrayItemsAndMapObjs = R.curry(function (fn, applyObj, key, left, right) {
  return R.cond([// Arrays
  [R.all(Array.isArray), // Recurse on each array item. We pass the key without the index
  function (lr) {
    return R.apply(R.zipWith(function (l, r) {
      return R.compose( // For array items, take key and the result and call the applyObj func, but only if res is an Object
      function (v) {
        return R.when( // When it's an object and not an array call applyObj
        // typeof x === 'object' check because sometimes values that are objects are not returning true
        R.both(function (vv) {
          return _typeof(vv) === 'object';
        }, R.complement(R.is)(Array)), function (res) {
          return applyObj(key, res);
        })(v);
      }, function (_ref15) {
        var _ref16 = _slicedToArray(_ref15, 3),
            kk = _ref16[0],
            ll = _ref16[1],
            rr = _ref16[2];

        return _mergeDeepWithRecurseArrayItemsAndMapObjs(fn, applyObj, kk, ll, rr);
      })([key, l, r]);
    }))(lr);
  }], // Primitives: call the function with left and right as the first two args and key as the last
  [R.complement(R.all)(function (x) {
    return isObject(x);
  }), function (lr) {
    return fn.apply(void 0, _toConsumableArray(lr).concat([key]));
  }], // Always leave functions alone.
  [function (lr) {
    return R.all(R.is(Function), lr);
  }, function (_ref17) {
    var _ref18 = _slicedToArray(_ref17, 2),
        l = _ref18[0],
        _ = _ref18[1];

    return l;
  }], // Objects
  [R.T, function (lr) {
    return R.apply(R.mergeWithKey(function (k, l, r) {
      return R.compose( // Take key and the result and call the applyObj func, but only if res is an Object
      function (v) {
        return R.when( // When it's an object and not an array call applyObj
        // typeof x === 'object' check because sometimes values that are objects are not returning true
        R.both(function (x) {
          return _typeof(x) === 'object';
        }, R.complement(R.is)(Array)), function (res) {
          return applyObj(k, res);
        })(v);
      }, // First recurse on l and r
      function (_ref19) {
        var _ref20 = _slicedToArray(_ref19, 3),
            kk = _ref20[0],
            ll = _ref20[1],
            rr = _ref20[2];

        return R.apply(_mergeDeepWithRecurseArrayItemsAndMapObjs(fn, applyObj), [kk, ll, rr]);
      })([k, l, r]);
    }), lr);
  }]])([left, right]);
});
/**
 * http://stackoverflow.com/questions/40011725/point-free-style-capitalize-function-with-ramda
 * Capitalize the first letter
 * @param {String} str The string to capitalize
 * @returns {String} The capitalized string
 * @sig capitalize:: String -> String
 */


var capitalize = function capitalize(str) {
  return R.compose(R.join(''), R.juxt([R.compose(R.toUpper, R.head), R.tail]))(str);
};
/**
 * http://stackoverflow.com/questions/40011725/point-free-style-capitalize-function-with-ramda
 * Lowercase the first letter
 * @param {String} str The string to lowercase
 * @returns {String} The capitalized string
 * @sig capitalize:: String -> String
 */

var lowercase = function lowercase(str) {
  return R.compose(R.join(''), R.juxt([R.compose(R.toLower, R.head), R.tail]))(str);
};
/**
 * From https://github.com/substack/camelize/blob/master/index.js
 * @param {String} str The string to camelCase
 * @returns {String} The camel-cased string
 */

var camelCase = function camelCase(str) {
  return R.toLower(str).replace(/[_.-](\w|$)/g, function (_, x) {
    return x.toUpperCase();
  });
};
/**
 * Merge a list of objects using the given concat function
 * [{k: v}] → {k: v}
 * @returns {Object} The merged object
 * @sig mergeAllWithKey:: (String → a → a → a) → [{a}] → {a}
 */

var mergeAllWithKey = R.curry(function (fn, _ref21) {
  var _ref22 = _toArray(_ref21),
      head = _ref22[0],
      rest = _ref22.slice(1);

  return R.mergeWithKey( // call mergeWithKey on two objects at a time
  fn, head || {}, // first object is always the head
  R.ifElse( // second object is the merged object of the recursion
  R.isEmpty, // if no rest
  function () {
    return R.empty({});
  }, // end case empty object
  mergeAllWithKey(fn) // else recurse with the rest
  )(rest));
});
/**
 * Get a required path or return a helpful Error if it fails
 * @param {String} path A lensPath, e.g. ['a', 'b'] or ['a', 2, 'b']
 * @param {Object} obj The object to inspect
 * @returns {Result} Result the resolved value or an Error
 * @sig reqPath:: String -> {k: v} → Result
 */

var reqPath = R.curry(function (path, obj) {
  return R.compose(R.ifElse( // If path doesn't resolve
  function (maybe) {
    return maybe.isNothing;
  }, // Create a useful Error message
  function () {
    return Result.Error({
      resolved: R.reduceWhile( // Stop if the accumulated segments can't be resolved
      function (segments, segment) {
        return R.not(R.isNil(R.path(R.concat(segments, [segment]), obj)));
      }, // Accumulate segments
      function (segments, segment) {
        return R.concat(segments, [segment]);
      }, [], path),
      path: path
    });
  }, // Return the resolved value
  function (res) {
    return Result.Ok(res.value);
  }), // Try to resolve the value using the path and obj, returning Maybe
  Rm.path(path))(obj);
});
/**
 * Expects a prop path and returns a function expecting props,
 * which resolves the prop indicated by the string. Returns Result.Error if there is not match
 * @param {String} str dot-separated prop path
 * @param {Object} props Object to resolve the path in
 * @return {Result} Result.Ok with the resolved value or Result.Error if the path doesn't exist or the
 * value is null
 */

var reqStrPath = R.curry(function (str, props) {
  return reqPath(R.split('.', str), props);
});
/**
 * Expects a prop path and returns a function expecting props,
 * which resolves the prop indicated by the string. If not match is found it returns undefined
 * @param {String} str dot-separated prop path
 * @param {Object} props Object to resolve the path in
 * @return {Object} The resolved object or undefined
 */

var strPath = R.curry(function (str, props) {
  return R.view(R.lensPath(R.split('.', str)), props);
});
/**
 * Like strPath but defaults the given value
 * @param {Object} defaultValue. Default value if value is null undefined.
 * @param {String} str dot-separated prop path
 * @param {Object} props Object to resolve the path in
 * @return {function(*=)}
 */

var strPathOr = R.curry(function (defaultValue, str, props) {
  var result = R.view(R.lensPath(R.split('.', str)), props);
  return R.when(R.isNil, R.always(defaultValue))(result);
});
var strPathOrNullOk = R.curry(function (defaultValue, str, props) {
  var segments = R.split('.', str);
  var result = R.view(R.lensPath(R.init(segments)), props);
  return R.ifElse(R.isNil, R.always(defaultValue), function (r) {
    try {
      return R.when(function (v) {
        return typeof v === 'undefined';
      }, function () {
        return defaultValue;
      })(R.prop(R.last(segments), r));
    } catch (_unused) {
      return defaultValue;
    }
  })(result);
});
/**
 * Returns true if the given string path is non-null
 * @param {String} str dot-separated prop path
 * @param {Object} props Object to resolve the path in
 * @returns {Boolean} true
 */

var hasStrPath = R.curry(function (str, props) {
  return R.complement(R.isNil)(R.view(R.lensPath(R.split('.', str)), props));
});
/**
 * Uses reqPath to resolve the path of an object and compares it to val
 * @param {String} path A lensPath, e.g. ['a', 'b'] or ['a', 2, 'b']
 * @param {*} val The val to do an equality check on
 * @param {Object} obj The object to inspect
 * @returns {Result} Result the resolved value or an Error
 * @sig reqPath:: String -> {k: v} → Result
 */

var reqPathPropEq = R.curry(function (path, val, obj) {
  return (// If the reqPath is valid map it to a comparison with val
    reqPath(path, obj).map(R.equals(val))
  );
});
/**
 * From the cookbook: https://github.com/ramda/ramda/wiki/Cookbook#map-keys-of-an-object
 * Maps keys according to the given function
 * @returns {Object} The mapped keys of the object
 * @sig mapKeys :: (String -> String) -> Object -> Object
 */

var mapKeys = R.curry(function (fn, obj) {
  return R.compose(R.fromPairs, function (pairs) {
    return R.map( // Apply fn to index 0 of pair
    function (pair) {
      return R.adjust(0, fn, pair);
    }, pairs);
  }, R.toPairs)(obj);
});
/**
 * Uses a lens to map keys that are embedded in a data structure
 * The lens must indicate an object whose keys shall be mapped
 * @returns {Object} Object with the keys indicated by the given lens mapped
 * @sig mapKeysForLens :: Lens -> ((String -> String) -> Object -> Object
 */

var mapKeysForLens = R.curry(function (lens, fn, obj) {
  return (// Sets the lens-focused objects to a new object with keys mapped according to the function
    R.set(lens, mapKeys(fn, R.view(lens, obj)), obj)
  );
});
/**
 * Converts default to desired name. Used for requiring defaults
 * @param {String} keyName The desired rename of 'default'
 * @param {Object} module A required module with a default key
 * @returns {Object} The import module with key default changed to keyName
 * @sig mapDefault :: String -> <k,v> -> <k,v>
 */

var mapDefault = function mapDefault(keyName, module) {
  return mapKeys(function (key) {
    return key === 'default' ? keyName : key;
  }, module);
};
/**
 * Converts default to desired name and prefixes others.
 * Used for requiring defaults and renaming others
 * @param {String} defaultName The desired rename of 'default'
 * @param {String} prefix The desired prefix for others. Camel Case maintained
 * @param {Object} module A required module with a default key
 * @returns {Object} The import module with key default changed to keyName
 * @sig mapDefault :: String -> <k,v> -> <k,v>
 */

var mapDefaultAndPrefixOthers = function mapDefaultAndPrefixOthers(defaultName, prefix, module) {
  return mapKeys(function (key) {
    return key === 'default' ? defaultName : "".concat(prefix).concat(capitalize(key));
  }, module);
};
/**
 * Maps an object with a function that returns pairs and create and object therefrom
 * Like R.mapObjIndexed, the function's first argument is the value of each item, and the seconds is the key if
 * iterating over objects
 * @params {Functor} f The mapping function
 * @params {Container} container Anything that can be mapped
 * @returns {Object} The mapped pairs made into key values
 * @sig mapKeysAndValues :: Functor F = (a -> [b,c]) -> F -> <k,v>
 */

var mapKeysAndValues = R.curry(function (f, container) {
  return R.fromPairs(mapObjToValues(f, container));
});
/**
 * https://github.com/ramda/ramda/wiki/Cookbook
 * Filter objects with values and keys. Null objs return as null
 * @param {Function} pred (value, key) => True|False
 * @param {Object} obj The object to filter
 * @returns {Object} The filtered object
 * @sig filterWithKeys:: (v -> k -> True|False) -> <k,v> -> <k,v>
 */

var filterWithKeys = R.curry(function (pred, obj) {
  if (!obj) {
    return obj;
  }

  return R.compose(R.fromPairs, R.filter(function (pair) {
    return R.apply(pred, R.reverse(pair));
  }), R.toPairs)(obj);
});
/**
 * Transforms the keys of the given object with the given func
 * @param {Function} func The mapping function that expects the key
 * @param {Object} The object to map
 * @returns {Object} The object with transformed keys and the original values
 */

var transformKeys = R.curry(function (func, obj) {
  return R.compose(R.fromPairs, R.map(function (_ref23) {
    var _ref24 = _slicedToArray(_ref23, 2),
        key = _ref24[0],
        value = _ref24[1];

    return [func(key), value];
  }), R.toPairs)(obj);
});
/**
 * Renames the key of the object specified by the lens
 * @param {Function} lens A ramda lens that points to the object containing the key, not the key itself.
 * Use R.lensPath([]) to operate directly on obj
 * @param {String} from Key to rename
 * @param {String} to New name for the key
 * @param {Object} obj Object to traverse with the lens
 */

var renameKey = R.curry(function (lens, from, to, obj) {
  return R.over(lens, function (target) {
    return mapKeys(R.when(R.equals(from), R.always(to)), target);
  }, obj);
});
/**
 * Duplicates the key of the object specified by the lens and key, to the given list of keys or single key.
 * A duplicate of the value at key will be added at each of the toKeys using R.clone
 * @param {Function} lens A ramda lens that points to the object containing the key, not the key itself
 * @param {String} key Key to duplicate the value of
 * @param {String|[String]} toKeys Array of new keys to make. New keys overwrite existing keys
 * @param {Object} obj Object to traverse with the lens
 */

var duplicateKey = R.curry(function (lens, key, toKeys, obj) {
  return R.over(lens, // convert the target of the lens to a merge of the target with copies of target[key]
  function (target) {
    return R.merge(target, R.fromPairs(R.map(function (toKey) {
      return [toKey, R.clone(target[key])];
    }, toArrayIfNot(toKeys))));
  }, // take the lens of this obj
  obj);
});
/**
 * Converts a scalar value (!Array.isArray) to array an array
 * @param {*|[*]} arrayOrScalar An array or scalar
 * @returns {[*]} The scalar as an array or the untouched array
 */

var toArrayIfNot = function toArrayIfNot(arrayOrScalar) {
  return R.unless(Array.isArray, Array.of)(arrayOrScalar);
};
/**
 * Like duplicateKey but removes the original key
 * @param {Function} lens A ramda lens that points to the object containing the key, not the key itself
 * @param {String} key Key to duplicate the value of
 * @param [{String}] toKeys Array of new keys to make. New keys overwrite existing keys
 * @param {Object} obj Object to traverse with the lens
 */

var moveToKeys = R.curry(function (lens, key, toKeys, obj) {
  return R.over(lens, // convert the target of the lens to a merge of the target with copies of target[key]
  // and with target[key] itself removed
  function (target) {
    return R.merge(R.omit([key], target), R.fromPairs(R.map(function (toKey) {
      return [toKey, R.clone(target[key])];
    }, toKeys)));
  }, // take the lens of this obj
  obj);
});
/**
 * Like R.find but expects only one match and works on both arrays and objects
 * Note this still iterates through the whole list or object, so this should be rewritten to quit when one is found
 * @param {Function} predicate
 * @param {Array|Object} obj Container that should only match once with predicate
 * @returns {Result} Result.Error if no matches or more than one, otherwise Result.Ok with the single matching item in an array/object
 */

var findOne = R.curry(function (predicate, obj) {
  return R.ifElse( // If path doesn't resolve
  function (items) {
    return R.equals(R.length(R.keys(items)), 1);
  }, // Return the resolved single key/value object
  function (items) {
    return Result.Ok(items);
  }, // Create a useful Error message
  function (items) {
    return Result.Error({
      all: obj,
      matching: items
    });
  })(R.filter(predicate, obj));
});
/**
 * Version of find one that accepts all items of the given Container
 * @param {Array|Object} obj Container
 * @returns {Result} Result.Error if no items or more than one, otherwise Result.Ok with the single item in an array/object
 */

var onlyOne = findOne(R.T);
/**
 * Like onlyOne but extracts the value
 * @param {Array|Object|Result} obj Container that should have one value to extract. This currently expects
 * and array or object or Result, but it could be expanded to take Result, Maybe, or any other container where
 * the value can be extracted. Types like Tasks and Streams can't extract, I suppose
 * @returns {Result} Result.Error if no items or more than one, otherwise Result.Ok with the single value
 */

var onlyOneValue = R.compose( // Use R.map to operate on the value of Result without extracting it
R.map(R.head), R.map(R.values), findOne(R.T));
/**
 * Curryable Maps container values to the key and values of an object, applying f to each to make the value
 * @param {Function} f Transforms each item to a value
 * @param {Array} list Container to map to an object.
 * @sig mapToObjValue:: Functor a => (b -> c) -> <b, c>
 */

var mapToObjValue = R.curry(function (f, obj) {
  return R.compose(R.fromPairs, R.map(function (v) {
    return [v, f(v)];
  }))(obj);
});
/**
 * Finds an item that matches all the given props in params
 * @param {Object} params object key values to match
 * @param {Object|Array} items Object or Array that can produce values to search
 * @returns {Result} An Result.Ok containing the value or an Result.Error if no value is found
 */

var findOneValueByParams = function findOneValueByParams(params, items) {
  return findOne( // Compare all the eqProps against each item
  R.allPass( // Create a eqProps for each prop of params
  R.map(function (prop) {
    return R.eqProps(prop, params);
  }, R.keys(params))), R.values(items)).map(R.head);
};
/**
 * Returns the items matching all param key values
 * @param {Object} params Key values to match to items
 * @param {Object|Array} items Object with values of objects or array of objects that can produce values to search
 * @returns {[Object]} items that pass
 */

var findByParams = function findByParams(params, items) {
  return R.filter( // Compare all the eqProps against each item
  R.allPass( // Create a eqProps for each prop of params
  R.map(function (prop) {
    return R.eqProps(prop, params);
  }, R.keys(params))), items);
};
/**
 * Returns the first mapped item that is not null
 * @param {Function} f The mapping function
 * @param {[*]} items The items
 * @returns {*} The first mapped item value that is not nil
 */

var findMapped = function findMapped(f, items) {
  return R.reduceWhile(R.isNil, function (_, i) {
    return f(i);
  }, null, items);
};
/**
 * Converts the given value to an always function (that ignores all arguments) unless already a function
 * @param {Function} maybeFunc A function or something else
 * @return {Function} a function that always returns the non funcion value of maybeFunc, or maybeFunc
 * itself if maybeFunc is a functon
 */

var alwaysFunc = function alwaysFunc(maybeFunc) {
  return R.unless(R.is(Function), R.always)(maybeFunc);
};
/**
 * Map the object with a function accepting a key, value, and the obj but return just the mapped values,
 * not the object
 * @param {Function} f Expects value, key, and obj
 * @param {Object} obj The object to map
 * @return {[Object]} Mapped values
 */

var mapObjToValues = R.curry(function (f, obj) {
  return R.values(R.mapObjIndexed(f, obj));
});
/**
 * Filter the given object and return the values, discarding the keys
 * @param {Function} f Receives each value and key
 * @param {Object} obj The object to filter
 * @return {Object} The filtered object values
 */

var filterObjToValues = R.curry(function (f, obj) {
  return R.values(filterWithKeys(f, obj));
});
/**
 * Like mapObjToValues but chains the values when an array is returned for each mapping
 * @param {Function} f Expects key, value, and obj
 * @param {Object} obj The object to chain
 * @return {[Object]} Mapped flattened values
 */

var chainObjToValues = R.curry(function (f, obj) {
  return R.chain(R.identity, mapObjToValues(f, obj));
});
/**
 *
 * This is a deep fromPairs. If it encounters a two element array it assumes it's a pair if the first
 * element is a string. If an array is not a pair it is iterated over and each element is recursed upon.
 * The 2nd element of each pair is also recursed upon. The end case for recursion is that an element is not an array.
 *
 * This method doesn't currently expect objects but could be easily modified to handle them
 * @param {[*]} deepPairs An array of deep pairs, with possibly other arrays at the top or lower levels
 * that aren't pairs but might contain them
 * @returns {Array|Object} All arrays of pairs are converted to objects. Arrays of non pairs are left as arrays
 */

var fromPairsDeep = function fromPairsDeep(deepPairs) {
  return R.cond([// It's array of pairs or some other array
  [Array.isArray, function (list) {
    return R.ifElse( // Is the first item a two element array whose first item is a string?
    function (_ref25) {
      var _ref26 = _slicedToArray(_ref25, 1),
          first = _ref26[0];

      return R.allPass([Array.isArray, function (x) {
        return R.compose(R.equals(2), R.length)(x);
      }, function (x) {
        return R.compose(R.is(String), R.head)(x);
      }])(first);
    }, // Yes, return an object whose keys are the first element and values are the result of recursing on the second
    function (l) {
      return R.compose(R.fromPairs, R.map(function (_ref27) {
        var _ref28 = _slicedToArray(_ref27, 2),
            k = _ref28[0],
            v = _ref28[1];

        return [k, fromPairsDeep(v)];
      }))(l);
    }, // No, recurse on each array item
    function (l) {
      return R.map(function (v) {
        return fromPairsDeep(v);
      }, l);
    })(list);
  }], // End case, return the given value unadulterated
  [R.T, R.identity]])(deepPairs);
};
/**
 * At the given depth, object and array values are converted to the replacementString.
 * @param {Number} n Depth to replace at.
 * Depth 3 converts {a: {b: {c: 1}}} to {a: {b: {c: '...'}}}
 * Depth 2 converts {a: {b: {c: 1}}} to {a: {b: '...'}}
 * Depth 1 converts {a: {b: {c: 1}}} to {a: '...'}
 * Depth 0 converts {a: {b: {c: 1}}} to '...'
 * @param {String|Function} replaceStringOrFunc String such as '...' or a unary function that replaces the value
 * e.g. R.when(isObject, R.length(R.keys)) will count objects and arrays but leave primitives alone
 * @param {Object} obj Object to process
 * @returns {Object} with the above transformation. Use replaceValuesAtDepthAndStringify to get a string
 */

function replaceValuesAtDepth(n, replaceStringOrFunc, obj) {
  return R.ifElse( // If we are above level 0 and we have an object
  R.both(R.always(R.lt(0, n)), isObject), // Then recurse on each object or array value
  function (o) {
    return R.map(function (oo) {
      return replaceValuesAtDepth(n - 1, replaceStringOrFunc, oo);
    }, o);
  }, // If at level 0 replace the value. If not an object or not at level 0, leave it alone
  function (o) {
    return R.when(R.always(R.equals(0, n)), alwaysFunc(replaceStringOrFunc))(o);
  })(obj);
}
/** *
 * replaceValuesAtDepth but stringifies result
 * @param {Number} n Depth to replace at.
 * Depth 3 converts {a: {b: {c: 1}}} to {a: {b: {c: '...'}}}
 * Depth 2 converts {a: {b: {c: 1}}} to {a: {b: '...'}}
 * Depth 1 converts {a: {b: {c: 1}}} to {a: '...'}
 * Depth 0 converts {a: {b: {c: 1}}} to '...'
 * @param {String|Function} replaceString String such as '...' or a unary function that replaces the value
 * e.g. R.when(isObject, R.length(R.keys)) will count objects and arrays but leave primitives alone
 * @param {Object} obj Object to process
 * @returns {String} after the above replacement
 */

var replaceValuesAtDepthAndStringify = function replaceValuesAtDepthAndStringify(n, replaceString, obj) {
  return JSON.stringify(replaceValuesAtDepth(n, replaceString, obj));
};
/**
 * Convenient method to count objects and lists at the given depth but leave primitives alone
 * @param {Number} n Depth to replace at.
 * @param {Object} obj Object to process
 * @returns {Object} after the above replacement
 */

var replaceValuesWithCountAtDepth = function replaceValuesWithCountAtDepth(n, obj) {
  return replaceValuesAtDepth(n, R.when(isObject, function (o) {
    return R.compose( // Show arrays and objs different
    R.ifElse(R.always(Array.isArray(o)), function (c) {
      return "[...".concat(c, "]");
    }, function (c) {
      return "{...".concat(c, "}");
    }), R.length, R.keys)(o);
  }), obj);
};
/**
 * Convenient method to count objects and lists at the given depth but leave primitives alone and stringify result
 * @param {Number} n Depth to replace at.
 * @param {Object} obj Object to process
 * @returns {String} after the above replacement
 */

var replaceValuesWithCountAtDepthAndStringify = function replaceValuesWithCountAtDepthAndStringify(n, obj) {
  return JSON.stringify(replaceValuesWithCountAtDepth(n, obj));
};
/**
 * Flattens an objects so deep keys and array indices become concatinated strings
 * E.g. {a: {b: [1, 3]}} => {'a.b.0': 1, 'a.b.1': 2}
 * @param {Object} obj The object to flattened
 * @returns {Object} The 1-D version of the object
 */

var flattenObj = function flattenObj(obj) {
  return R.fromPairs(_flattenObj({}, obj));
};
/**
 * Flatten objs until the predicate returns false. This is called recursively on each object and array
 * @param {Function} predicate Expects object, returns true when we should stop flatting on the current object
 * @param {Object} obj The object to flatten
 * @return {Object} The flattened object
 */

var flattenObjUntil = function flattenObjUntil(predicate, obj) {
  return R.fromPairs(_flattenObj({
    predicate: predicate
  }, obj));
};

var _flattenObj = function _flattenObj(config, obj) {
  var keys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
  var predicate = R.propOr(null, 'predicate', config);
  return R.ifElse( // If we have an object
  function (o) {
    return R.both(isObject, function (oo) {
      return R.when(function () {
        return predicate;
      }, function (ooo) {
        return R.complement(predicate)(ooo);
      })(oo);
    })(o);
  }, // Then recurse on each object or array value
  function (o) {
    return chainObjToValues(function (oo, k) {
      return _flattenObj(config, oo, R.concat(keys, [k]));
    }, o);
  }, // If not an object return flat pair
  function (o) {
    return [[R.join('.', keys), o]];
  })(obj);
};
/**
 * Converts a key string like 'foo.bar.0.wopper' to ['foo', 'bar', 0, 'wopper']
 * @param {String} keyString The dot-separated key string
 * @returns {[String]} The lens array containing string or integers
 */


var keyStringToLensPath = function keyStringToLensPath(keyString) {
  return R.map(R.when(R.compose(R.complement(R.equals)(NaN), parseInt), parseInt), R.split('.', keyString));
};
/**
 * Undoes the work of flattenObj. Does not allow number keys to become array indices
 * @param {Object} obj 1-D object in the form returned by flattenObj
 * @returns {Object} The original
 */

var unflattenObjNoArrays = function unflattenObjNoArrays(obj) {
  return _unflattenObj({
    allowArrays: false
  }, obj);
};
/**
 * Undoes the work of flattenObj
 * @param {Object} obj 1-D object in the form returned by flattenObj
 * @returns {Object} The original
 */

var unflattenObj = function unflattenObj(obj) {
  return _unflattenObj({
    allowArrays: true
  }, obj);
};
var _unflattenObj = function _unflattenObj(config, obj) {
  return R.compose(R.reduce(function (accum, _ref29) {
    var _ref30 = _slicedToArray(_ref29, 2),
        keyString = _ref30[0],
        value = _ref30[1];

    // Don't allow indices if allowArrays is false
    var itemKeyPath = R.map(function (key) {
      return R.when(function () {
        return R.not(R.prop('allowArrays', config));
      }, function (k) {
        return k.toString();
      })(key);
    }, keyStringToLensPath(keyString)); // Current item lens

    var itemLensPath = R.lensPath(itemKeyPath); // All but the last segment gives us the item container len

    var constainerKeyPath = R.init(itemKeyPath);
    var container = R.unless( // If the path has any length (not []) and the value is set, don't do anything
    R.both(R.always(R.length(constainerKeyPath)), R.view(R.lensPath(constainerKeyPath))), // Else we are at the top level, so use the existing accum or create a [] or {}
    // depending on if our item key is a number or not
    function (x) {
      return R.defaultTo(R.ifElse(function (v) {
        return R.both(function () {
          return R.prop('allowArrays', config);
        }, R.is(Number))(v);
      }, R.always([]), R.always({}))(R.head(itemKeyPath)))(x);
    })(accum); // Finally set the container at the itemLensPath

    return R.set(itemLensPath, value, container);
  }, // null initial value
  null), R.toPairs)(obj);
};
/**
 * Does something to every object
 * @param {Function} func Called on each object that is the child of another object. Called with the key that
 * points at it from the parent object and the object itself
 * @param {Object} obj The object to process
 */

var overDeep = R.curry(function (func, obj) {
  return mergeDeepWithRecurseArrayItemsAndMapObjs( // We are using a mergeDeepWithRecurseArrayItemsAndMapObjs but we only need the second function
  function (l, r, k) {
    return l;
  }, func, // Use obj twice so that all keys match and get called with the merge function
  obj, obj);
});
/**
 * Omit the given keys anywhere in a data structure. Objects and arrays are recursed and omit_deep is called
 * on each dictionary that hasn't been removed by omit_deep at a higher level
 */

var omitDeep = R.curry(function (omit_keys, obj) {
  return omitDeepBy(function (k, v) {
    return R.includes(k, omit_keys);
  }, obj);
});
/**
 * Omit by the given function that is called with key and value. You can ignore the value if you only want to test the key
 * Objects and arrays are recursed and omit_deep is called
 * on each dictionary that hasn't been removed by omit_deep at a higher level
 * @param {Function} f Binary function accepting each key, value. Return non-nil to omit and false or nil to keep
 */

var omitDeepBy = R.curry(function (f, obj) {
  return R.compose(function (o) {
    return applyDeepAndMapObjs( // If k is in omit_keys return {} to force the applyObj function to call. Otherwise take l since l and r are always the same
    // l and r are always the same value
    function (l, r, kk) {
      return R.ifElse( // Reject any function return value that isn't null or false
      function (k) {
        return R.anyPass([R.isNil, R.equals(false)])(f(k, l));
      }, R.always(l), function () {
        return {};
      })(kk);
    }, // Called as the result of each recursion. Removes the keys at any level except the topmost level
    function (key, result) {
      return filterWithKeys(function (v, k) {
        return R.anyPass([R.isNil, R.equals(false)])(f(k, v));
      }, result);
    }, o);
  }, // Omit at the top level. We have to do this because applyObj of applyDeepAndMapObjs only gets called starting
  // on the object of each key
  // Reject any function return value that isn't null or false
  function (o) {
    return filterWithKeys(function (v, k) {
      return R.anyPass([R.isNil, R.equals(false)])(f(k, v));
    }, o);
  })(obj);
});
/**
 * Given a predicate for eliminating an item based on paths, return the paths of item that don't pass the predicate.
 * keyOrIndex is the object key or array index that the item came from. We use it for the eliminateItemPredicate
 * test. If each paths current first segment matches keyOrIndex or equals '*', we consider that path.
 * With the considered paths
 * @param {Function} eliminateItemPredicate Accepts the remaining paths and optional item as a second argument.
 * Returns true if the item shall be eliminated
 * @param {[String]} paths Paths to caculate if they match the item
 * @param {*} item Item to test
 * @param {String|Number} keyOrIndex The key or index that the item belonged to of an object or array
 * @return {Object} {item: the item, paths: remaining paths with first segment removed}. Or null if eliminateItemPredicate
 * returns true
 * @private
 */

var _calculateRemainingPaths = function _calculateRemainingPaths(eliminateItemPredicate, paths, item, keyOrIndex) {
  // Keep paths that match keyOrIndex as the first item. Remove other paths
  // since they can't match item or its descendants
  var tailPathsStillMatchingItemPath = compact(R.map(R.compose(R.ifElse(R.compose(function (aKeyOrIndex) {
    return R.ifElse( // if keyOrIndex is a string and matches the shape of a regex: /.../[gim]
    function (possibleRegex) {
      return R.both(R.is(String), function (str) {
        return R.test(regexToMatchARegex, str);
      })(possibleRegex);
    }, // Construct the regex with one or two, the expression and options (gim)
    function (provenRegex) {
      var args = compactEmpty(R.split('/', provenRegex));
      return _construct(RegExp, _toConsumableArray(args)).test(keyOrIndex);
    }, // If aKeyOrIndex is '*' or equals keyOrIndex always return true
    function (str) {
      return R.includes(str, ['*', keyOrIndex]);
    })(aKeyOrIndex);
  }, R.head), // Matches the keyOrIndex at the head. Return the tail
  R.tail, // Mark null to remove from list
  R.always(null)), // Convert path to array with string keys and number indexes
  keyStringToLensPath), paths)); // For omit:
  // If any path matches the path to the item return null so we can throw away the item
  // If no path is down to zero length return the item and the paths
  // For pick:
  // If no path matches the path to the item return null so we can throw away the item
  // If any path is not down to zero return the item and the paths, unless item is a primitive meaning it can't match
  // a path

  return R.ifElse(function (tailPaths) {
    return eliminateItemPredicate(tailPaths, item);
  }, R.always(null), function (p) {
    return {
      item: item,
      paths: R.map(R.join('.'), p)
    };
  })(tailPathsStillMatchingItemPath);
}; // This predicate looks for any path that's zero length, meaning it matches the path to an item and we should
// omit that item


var _omitDeepPathsEliminateItemPredicate = function _omitDeepPathsEliminateItemPredicate(paths) {
  return R.any(R.compose(R.equals(0), R.length), paths);
};
/**
 * Omit matching paths in a a structure. For instance omitDeepPaths(['a.b.c', 'a.0.1']) will omit keys
 * c in {a: {b: c: ...}}} and 'y' in {a: [['x', 'y']]}
 */


var omitDeepPaths = R.curry(function (pathSet, obj) {
  return R.cond([// Arrays
  [function (o) {
    return Array.isArray(o);
  }, function (list) {
    // Recurse on each array item that doesn't match the paths.
    // We pass the key without the index
    // If any path matches the path to the value we return the item and the matching paths
    var survivingItems = compact(R.addIndex(R.map)(function (item, index) {
      return _calculateRemainingPaths(_omitDeepPathsEliminateItemPredicate, pathSet, item, index);
    }, list));
    return R.map(function (_ref31) {
      var paths = _ref31.paths,
          item = _ref31.item;
      return omitDeepPaths(paths, item);
    }, survivingItems);
  }], // Primitives always pass.
  [R.complement(isObject), function (primitive) {
    return primitive;
  }], // Objects
  [R.T, function (o) {
    // Recurse on each object value that doesn't match the paths.
    var survivingItems = compact(R.mapObjIndexed( // If any path matches the path to the value we return the value and the matching paths
    // If no path matches it we know the value shouldn't be omitted so we don't recurse on it below
    function (value, key) {
      return _calculateRemainingPaths(_omitDeepPathsEliminateItemPredicate, pathSet, value, key);
    }, o)); // Only recurse on items from the object that are still eligible for omitting

    return R.map(function (_ref32) {
      var paths = _ref32.paths,
          item = _ref32.item;
      return omitDeepPaths(paths, item);
    }, survivingItems);
  }]])(obj);
}); // This eliminate predicate returns true if no path is left matching the item's path so the item should not
// be picked. It also returns true if the there are paths with length greater than 0
// but item is a primitive, meaning it can't match a path

var _pickDeepPathsEliminateItemPredicate = function _pickDeepPathsEliminateItemPredicate(paths, item) {
  return R.either(R.compose(R.equals(0), R.length), function (pths) {
    return R.both( // Item is not an object
    function () {
      return R.complement(R.is)(Object, item);
    }, function (ps) {
      return R.any(R.compose(R.lt(0), R.length), ps);
    })(pths);
  })(paths);
};
/**
 * Pick matching paths in a a structure. For instance pickDeepPaths(['a.b.c', 'a.0.1']) will pick only keys
 * c in {a: {b: c: ...}}} and 'y' in {a: [['x', 'y']]}.
 * Use * in the path to capture all array items or keys, e.g. ['a.*.c./1|3/']
 * to get all items 0 or 3 of c that is in all items of a, whether a is an object or array
 */


var pickDeepPaths = R.curry(function (pathSet, obj) {
  return R.cond([// Arrays
  [function (o) {
    return Array.isArray(o);
  }, function (list) {
    // Recurse on each array item that doesn't match the paths. We pass the key without the index
    // We pass the key without the index
    // If any path matches the path to the value we return the item and the matching paths
    var survivingItemsEachWithRemainingPaths = compact(R.addIndex(R.map)(function (item, index) {
      return _calculateRemainingPaths(_pickDeepPathsEliminateItemPredicate, pathSet, item, index);
    }, list));
    return R.map(R.ifElse( // If the only paths are now empty we have a match with the items path and keep the item.
    // Otherwise we pick recursively
    function (_ref33) {
      var paths = _ref33.paths;
      return R.all(R.compose(R.equals(0), R.length), paths);
    }, function (_ref34) {
      var item = _ref34.item;
      return item;
    }, function (_ref35) {
      var item = _ref35.item,
          paths = _ref35.paths;
      return pickDeepPaths(paths, item);
    }), survivingItemsEachWithRemainingPaths);
  }], // Primitives never match because we'd only get here if we have pathSets remaining and no path can match a primitive
  [R.complement(isObject), function () {
    throw new Error('pickDeepPaths encountered a value that is not an object or array at the top level. This should never happens and suggests a bug in this function');
  }], // Objects
  [R.T, function (o) {
    // Recurse on each array item that doesn't match the paths. We pass the key without the index
    // If any path matches the path to the value we return the value and the matching paths
    // If no path matches it we know the value shouldn't be picked so we don't recurse on it below
    var survivingItems = compact(R.mapObjIndexed(function (item, key) {
      return _calculateRemainingPaths(_pickDeepPathsEliminateItemPredicate, pathSet, item, key);
    }, o));
    return R.map(R.ifElse( // If the only path is now empty we have a match with the items path and keep the item.
    // Otherwise we pick recursively
    function (_ref36) {
      var item = _ref36.item,
          paths = _ref36.paths;
      return R.all(R.compose(R.equals(0), R.length), paths);
    }, R.prop('item'), function (_ref37) {
      var item = _ref37.item,
          paths = _ref37.paths;
      return pickDeepPaths(paths, item);
    }), survivingItems);
  }]])(obj);
});
/**
 * splitAt that gives the split point item to both sides of the split
 * @param {Number} index The index
 * @param {String|[Object]} list A string or list
 * @returns {[Object]} A pair of results
 */

var splitAtInclusive = function splitAtInclusive(index, list) {
  var pair = R.splitAt(index, list);
  return [R.concat(R.head(pair), R.slice(0, 1, R.last(pair))), R.last(pair)];
};
/**
 * Whether the objects are equal at the given propStr. Null objects are never equal
 * @param {String} stringPath Path of props separated by dots
 * @param {Object|Array} obj1 The object to compare to obj2 at the propStr
 * @param {Object|Array} obj2 The object to compare to obj1 at the propStr
 * @returns {Boolean} True or false
 */

var eqStrPath = R.curry(function (stringPath, obj1, obj2) {
  return R.apply(R.equals, R.map(strPathOr(null, stringPath), [obj1, obj2]));
});
/**
 * Whether the objects are equal at the given strPaths. Null objects are never equal
 * @param [{String}] strPaths Paths of props separated by dots
 * @param {Object|Array} obj1 The object to compare to obj2 at the propStr
 * @param {Object|Array} obj2 The object to compare to obj1 at the propStr
 * @returns {Boolean} True or false
 */

var eqStrPathsAll = R.curry(function (strPaths, obj1, obj2) {
  return R.all(function (prop) {
    return eqStrPath(prop, obj1, obj2);
  }, strPaths);
});

exports._defineProperty = _defineProperty;
exports._mergeDeepWithRecurseArrayItemsByRight = _mergeDeepWithRecurseArrayItemsByRight;
exports._slicedToArray = _slicedToArray;
exports._toConsumableArray = _toConsumableArray;
exports._typeof = _typeof;
exports._unflattenObj = _unflattenObj;
exports.alwaysFunc = alwaysFunc;
exports.applyDeep = applyDeep;
exports.applyDeepAndMapObjs = applyDeepAndMapObjs;
exports.camelCase = camelCase;
exports.capitalize = capitalize;
exports.chainObjToValues = chainObjToValues;
exports.compact = compact;
exports.compactEmpty = compactEmpty;
exports.compactJoin = compactJoin;
exports.duplicateKey = duplicateKey;
exports.emptyToNull = emptyToNull;
exports.eqStrPath = eqStrPath;
exports.eqStrPathsAll = eqStrPathsAll;
exports.filterObjToValues = filterObjToValues;
exports.filterWithKeys = filterWithKeys;
exports.findByParams = findByParams;
exports.findMapped = findMapped;
exports.findOne = findOne;
exports.findOneValueByParams = findOneValueByParams;
exports.flattenObj = flattenObj;
exports.flattenObjUntil = flattenObjUntil;
exports.fromPairsDeep = fromPairsDeep;
exports.hasStrPath = hasStrPath;
exports.idOrIdFromObj = idOrIdFromObj;
exports.isObject = isObject;
exports.keyStringToLensPath = keyStringToLensPath;
exports.lowercase = lowercase;
exports.mapDefault = mapDefault;
exports.mapDefaultAndPrefixOthers = mapDefaultAndPrefixOthers;
exports.mapKeys = mapKeys;
exports.mapKeysAndValues = mapKeysAndValues;
exports.mapKeysForLens = mapKeysForLens;
exports.mapObjToValues = mapObjToValues;
exports.mapProp = mapProp;
exports.mapPropValueAsIndex = mapPropValueAsIndex;
exports.mapToObjValue = mapToObjValue;
exports.mergeAllWithKey = mergeAllWithKey;
exports.mergeDeep = mergeDeep;
exports.mergeDeepAll = mergeDeepAll;
exports.mergeDeepWith = mergeDeepWith;
exports.mergeDeepWithConcatArrays = mergeDeepWithConcatArrays;
exports.mergeDeepWithRecurseArrayItems = mergeDeepWithRecurseArrayItems;
exports.mergeDeepWithRecurseArrayItemsAndMapObjs = mergeDeepWithRecurseArrayItemsAndMapObjs;
exports.mergeDeepWithRecurseArrayItemsByAndMergeObjectByRight = mergeDeepWithRecurseArrayItemsByAndMergeObjectByRight;
exports.mergeDeepWithRecurseArrayItemsByRight = mergeDeepWithRecurseArrayItemsByRight;
exports.moveToKeys = moveToKeys;
exports.omitDeep = omitDeep;
exports.omitDeepBy = omitDeepBy;
exports.omitDeepPaths = omitDeepPaths;
exports.onlyOne = onlyOne;
exports.onlyOneValue = onlyOneValue;
exports.orEmpty = orEmpty;
exports.overDeep = overDeep;
exports.pickDeepPaths = pickDeepPaths;
exports.removeDuplicateObjectsByProp = removeDuplicateObjectsByProp;
exports.renameKey = renameKey;
exports.replaceValuesAtDepth = replaceValuesAtDepth;
exports.replaceValuesAtDepthAndStringify = replaceValuesAtDepthAndStringify;
exports.replaceValuesWithCountAtDepth = replaceValuesWithCountAtDepth;
exports.replaceValuesWithCountAtDepthAndStringify = replaceValuesWithCountAtDepthAndStringify;
exports.reqPath = reqPath;
exports.reqPathPropEq = reqPathPropEq;
exports.reqStrPath = reqStrPath;
exports.splitAtInclusive = splitAtInclusive;
exports.strPath = strPath;
exports.strPathOr = strPathOr;
exports.strPathOrNullOk = strPathOrNullOk;
exports.toArrayIfNot = toArrayIfNot;
exports.transformKeys = transformKeys;
exports.unflattenObj = unflattenObj;
exports.unflattenObjNoArrays = unflattenObjNoArrays;
//# sourceMappingURL=functions-b6202a08.js.map