fx.js

/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
var L_namespaceObject = {};
__webpack_require__.r(L_namespaceObject);
__webpack_require__.d(L_namespaceObject, "L", function() { return L; });
__webpack_require__.d(L_namespaceObject, "deepFlatLazy", function() { return deepFlatLazy; });
__webpack_require__.d(L_namespaceObject, "entriesLazy", function() { return entriesLazy; });
__webpack_require__.d(L_namespaceObject, "mapEntriesLazy", function() { return Lazy_mapEntriesLazy; });
__webpack_require__.d(L_namespaceObject, "filterLazy", function() { return Lazy_filterLazy; });
__webpack_require__.d(L_namespaceObject, "flatLazy", function() { return flatLazy; });
__webpack_require__.d(L_namespaceObject, "flatMapLazy", function() { return Lazy_flatMapLazy; });
__webpack_require__.d(L_namespaceObject, "headTailLazy", function() { return headTailLazy; });
__webpack_require__.d(L_namespaceObject, "indexValuesLazy", function() { return indexValuesLazy; });
__webpack_require__.d(L_namespaceObject, "keysLazy", function() { return keysLazy; });
__webpack_require__.d(L_namespaceObject, "mapLazy", function() { return Lazy_mapLazy; });
__webpack_require__.d(L_namespaceObject, "rangeLazy", function() { return rangeLazy; });
__webpack_require__.d(L_namespaceObject, "rejectLazy", function() { return Lazy_rejectLazy; });
__webpack_require__.d(L_namespaceObject, "reverseLazy", function() { return reverseLazy; });
__webpack_require__.d(L_namespaceObject, "valuesLazy", function() { return valuesLazy; });
__webpack_require__.d(L_namespaceObject, "takeLazy", function() { return Lazy_takeLazy; });
__webpack_require__.d(L_namespaceObject, "takeWhileLazy", function() { return Lazy_takeWhileLazy; });
__webpack_require__.d(L_namespaceObject, "takeUntilLazy", function() { return Lazy_takeUntilLazy; });
__webpack_require__.d(L_namespaceObject, "intervalLazy", function() { return intervalLazy; });
__webpack_require__.d(L_namespaceObject, "dropLazy", function() { return Lazy_dropLazy; });
var C_namespaceObject = {};
__webpack_require__.r(C_namespaceObject);
__webpack_require__.d(C_namespaceObject, "C", function() { return C; });
__webpack_require__.d(C_namespaceObject, "tailC", function() { return tailC; });
__webpack_require__.d(C_namespaceObject, "reduceC", function() { return Concurrency_reduceC; });
__webpack_require__.d(C_namespaceObject, "takeC", function() { return Concurrency_takeC; });
__webpack_require__.d(C_namespaceObject, "mapEntriesC", function() { return Concurrency_mapEntriesC; });
__webpack_require__.d(C_namespaceObject, "findC", function() { return Concurrency_findC; });
__webpack_require__.d(C_namespaceObject, "mapC", function() { return Concurrency_mapC; });
__webpack_require__.d(C_namespaceObject, "everyC", function() { return Concurrency_everyC; });
__webpack_require__.d(C_namespaceObject, "filterC", function() { return Concurrency_filterC; });
__webpack_require__.d(C_namespaceObject, "takeAllC", function() { return takeAllC; });
__webpack_require__.d(C_namespaceObject, "headC", function() { return headC; });
__webpack_require__.d(C_namespaceObject, "take1C", function() { return take1C; });
__webpack_require__.d(C_namespaceObject, "callsC", function() { return callsC; });
__webpack_require__.d(C_namespaceObject, "someC", function() { return Concurrency_someC; });
__webpack_require__.d(C_namespaceObject, "dropC", function() { return Concurrency_dropC; });

// CONCATENATED MODULE: ./curry.js
function curry(f) {
  return (a, ..._) => _.length < 1 ? (..._) => f(a, ..._) : f(a, ..._);
}
// CONCATENATED MODULE: ./empty.js
/* harmony default export */ var empty = (function *() {} ());

// CONCATENATED MODULE: ./toIter.js


function toIter(iterable) {
  return iterable && iterable[Symbol.iterator] ? iterable[Symbol.iterator]() : empty;
}
// CONCATENATED MODULE: ./nop.js
const nop = Symbol.for('nop');

/* harmony default export */ var nop_0 = (nop);
// CONCATENATED MODULE: ./go1.js
function go1(a, f) {
  return a instanceof Promise ? a.then(f) : f(a);
}
// CONCATENATED MODULE: ./take.js




/* harmony default export */ var take_0 = (curry(function take(l, iter) {
  if (l < 1) return [];
  let res = [];
  iter = toIter(iter);
  return function recur() {
    let cur;
    while (!(cur = iter.next()).done) {
      const a = cur.value;
      if (a instanceof Promise) {
        return a
          .then(a => (res.push(a), res).length == l ? res : recur())
          .catch(e => e == nop_0 ? recur() : Promise.reject(e));
      }
      res.push(a);
      if (res.length == l) return res;
    }
    return res;
  } ();
}));
// CONCATENATED MODULE: ./head.js



function head(iter) {
  return go1(take_0(1, iter), ([h]) => h);
}
// CONCATENATED MODULE: ./reduce.js





const call2 = (acc, a, f) =>
  a instanceof Promise ?
    a.then(a => f(acc, a), e => e == nop_0 ? acc : Promise.reject(e)) :
    f(acc, a);

function reduce(f, acc, iter) {
  if (arguments.length == 1) return (..._) => reduce(f, ..._);
  if (arguments.length == 2) return reduce(f, head(iter = toIter(acc)), iter);

  iter = toIter(iter);
  return go1(acc, function recur(acc) {
    let cur;
    while (!(cur = iter.next()).done) {
      acc = call2(acc, cur.value, f);
      if (acc instanceof Promise) return acc.then(recur);
    }
    return acc;
  });
}
// CONCATENATED MODULE: ./minBy.js



/* harmony default export */ var minBy_0 = (curry(function minBy(f, iter) {
  return reduce((a, b) => f(a) <= f(b) ? a : b, iter);
}));
// CONCATENATED MODULE: ./call.js
function call(a, f) {
  return f(a);
}
// CONCATENATED MODULE: ./pipe.js



function pipe(f, ...fs) {
  return (...as) => reduce(call, f(...as), fs);
}
// CONCATENATED MODULE: ./isArray.js
const { isArray } = Array;

/* harmony default export */ var isArray_0 = (isArray);
// CONCATENATED MODULE: ./baseSortBy.js



const arrComparator = (arr) => (a, b) => {
  let i = -1;
  while (++i < arr.length) {
    const ai = a[arr[i]], bi = b[arr[i]];
    if (ai === bi) continue;
    return ai < bi ? -1 : 1;
  }
  return 0;
};

function baseSortBy(left, right, f, arr) {
  return isArray_0(f) ? baseSortBy(left, right, arrComparator(f), arr) :
    typeof f == 'string' ? baseSortBy(left, right, a => a[f], arr) :
    f.length == 2 ? [...arr].sort(right == -1 ? pipe(f, n => n * -1) : f) :
    [...arr].sort((a, b, fa = f(a), fb = f(b)) => fa == fb ? 0 : fa < fb ? left : right)
}
// CONCATENATED MODULE: ./sortByDesc.js



/* harmony default export */ var sortByDesc_0 = (curry(function sortByDesc(f, arr) {
  return baseSortBy(1, -1, f, arr);
}));
// CONCATENATED MODULE: ./sortDesc.js


function sort(arr) {
  return sortByDesc_0(a => a, arr);
}
// CONCATENATED MODULE: ./go.js



function go(..._) {
  return reduce(call, _);
}
// CONCATENATED MODULE: ./isStop.js
const SymbolStop = Symbol.for('stop');

function isStop(a) {
  return !!(a && a[SymbolStop]);
}
// CONCATENATED MODULE: ./reduceS.js






const reduceS_call2 = (acc, a, f) =>
  a instanceof Promise ?
    a.then(a => f(acc, a), e => e == nop_0 ? acc : Promise.reject(e)) :
    f(acc, a);

function reduceS(f, acc, iter) {
  if (arguments.length == 1) return (..._) => reduceS(f, ..._);
  if (arguments.length == 2) return reduceS(f, head(iter = toIter(acc)), iter);

  iter = toIter(iter);
  return go1(acc, function recur(acc) {
    let cur;
    while (!isStop(acc) && !(cur = iter.next()).done) {
      acc = reduceS_call2(acc, cur.value, f);
      if (acc instanceof Promise) return acc.then(recur);
    }
    return isStop(acc) ? acc.value : acc;
  });
}
// CONCATENATED MODULE: ./goS.js



function goS(..._) {
  return reduceS(call, _);
}
// CONCATENATED MODULE: ./identity.js
/* harmony default export */ var identity = (a => a);
// CONCATENATED MODULE: ./stop.js
const stop_SymbolStop = Symbol.for('stop');

function stop(value) {
  return { [stop_SymbolStop]: true, value };
}
// CONCATENATED MODULE: ./Lazy/valuesLazy.js
function *valuesLazy(obj) {
  for (const k in obj) yield obj[k];
}
// CONCATENATED MODULE: ./takeAll.js


function takeAll(iter) {
  return take_0(Infinity, iter);
}
// CONCATENATED MODULE: ./values.js



function values(a) {
  return takeAll(valuesLazy(a));
}
// CONCATENATED MODULE: ./safety.js


function safety(a) {
  return a != null && !!a[Symbol.iterator] ? a : empty;
}
// CONCATENATED MODULE: ./Lazy/filterLazy.js





/* harmony default export */ var Lazy_filterLazy = (curry(function *filterLazy(f, iter) {
  for (const a of safety(iter)) {
    const b = go1(a, f);
    if (b instanceof Promise) yield b.then(b => b ? a : Promise.reject(nop_0));
    else if (b) yield a;
  }
}));
// CONCATENATED MODULE: ./find.js




/* harmony default export */ var find_0 = (curry(function find(f, iter) {
  return head(Lazy_filterLazy(f, iter));
}));
// CONCATENATED MODULE: ./not.js
function not(a) {
  return !a;
}
// CONCATENATED MODULE: ./Lazy/rejectLazy.js





/* harmony default export */ var Lazy_rejectLazy = (curry(function rejectLazy(f, iter) {
  return Lazy_filterLazy(a => go1(f(a), not), iter);
}));
// CONCATENATED MODULE: ./take1.js


const take1 = take_0(1);

/* harmony default export */ var take1_0 = (take1);
// CONCATENATED MODULE: ./every.js





/* harmony default export */ var every_0 = (curry(function every(f, iter) {
  return go1(take1_0(Lazy_rejectLazy(f, iter)), ({length}) => length == 0);
}));
// CONCATENATED MODULE: ./Lazy/entriesLazy.js
function *entriesLazy(obj) {
  for (const k in obj) yield [k, obj[k]];
}
// CONCATENATED MODULE: ./isMatch.js





/* harmony default export */ var isMatch_0 = (curry(function isMatch(a, b) {
  return (
    typeof a == 'function' ? !!a(b)
      :
    isArray_0(a) && isArray_0(b) ? every_0(v => b.includes(v), a)
      :
    typeof b == 'object' ? every_0(([k, v]) => b[k] == v, entriesLazy(a))
      :
    a instanceof RegExp ? b.match(a)
      :
    a == b
  );
}));
// CONCATENATED MODULE: ./match.js






function baseMatch(targets) {
  var cbs = [];

  function evl() {
    return go(
      targets,
      values,
      targets =>
        go(cbs,
          find_0(pb => { return pb._case(...targets); }),
          pb => pb._body(...targets)));
  }

  function _case(f) {
    cbs.push({ _case: typeof f == 'function' ? pipe(...arguments) : isMatch_0(f) });
    return _body;
  }
  _case.case = _case;

  function _body() {
    cbs[cbs.length-1]._body = pipe(...arguments);
    return _case;
  }

  _case.else = function() {
    _case(_=> true) (...arguments);
    return targets ? evl() : (...targets2) => ((targets = targets2), evl());
  };

  return _case;
}

function match(..._) {
  return baseMatch(_);
}

match.case = (..._) => baseMatch(null).case(..._);

/* harmony default export */ var match_0 = (match);
// CONCATENATED MODULE: ./stopIf.js



function stopIf(f, stopVal) {
  return match_0.case(f)(arguments.length == 2 ? _ => stop(stopVal) : stop).else(a => a);
}
// CONCATENATED MODULE: ./object.js


function object_object(iter) {
  return reduce((obj, [k, v]) => (obj[k] = v, obj), {}, iter);
}
// CONCATENATED MODULE: ./basePick.js




function basePick(filter, ks, obj) {
  return go(
    obj,
    entriesLazy,
    filter(([k]) => ks.includes(k)),
    object_object);
}

/* harmony default export */ var basePick_0 = (basePick);
// CONCATENATED MODULE: ./omit.js




/* harmony default export */ var omit_0 = (curry(function omit(ks, obj) {
  return basePick_0(Lazy_rejectLazy, ks, obj);
}));
// CONCATENATED MODULE: ./groupBy.js



function pushSel(parent, k, v) {
  (parent[k] || (parent[k] = [])).push(v);
  return parent;
}

/* harmony default export */ var groupBy_0 = (curry(function groupBy(f, iter) {
  return reduce((group, a) => pushSel(group, f(a), a), {}, iter);
}));
// CONCATENATED MODULE: ./tap.js




function tap(f, ...fs) {
  return (a, ...as) => go1(reduce(call, f(a, ...as), fs), _ => a);
}
// CONCATENATED MODULE: ./pipeS.js



function pipeS(f, ...fs) {
  return (...as) => reduceS(call, f(...as), fs);
}
// CONCATENATED MODULE: ./isString.js
function isString(a) {
  return typeof a == 'string';
}
// CONCATENATED MODULE: ./maxBy.js



/* harmony default export */ var maxBy_0 = (curry(function maxBy(f, iter) {
  return reduce((a, b) => f(a) >= f(b) ? a : b, iter);
}));
// CONCATENATED MODULE: ./max.js


function max(iter) {
  return maxBy_0(a => a, iter);
}
// CONCATENATED MODULE: ./Lazy/mapLazy.js




/* harmony default export */ var Lazy_mapLazy = (curry(function *mapLazy(f, iter) {
  for (const a of safety(iter)) yield go1(a, f);
}));
// CONCATENATED MODULE: ./map.js




/* harmony default export */ var map_0 = (curry(function map(f, iter) {
  return takeAll(Lazy_mapLazy(f, iter));
}));
// CONCATENATED MODULE: ./pluck.js



/* harmony default export */ var pluck_0 = (curry(function pluck(k, iter) {
  return map_0(a => a[k], iter);
}));
// CONCATENATED MODULE: ./countBy.js



function incSel(parent, k) {
  parent[k] ? parent[k]++ : parent[k] = 1;
  return parent;
}

/* harmony default export */ var countBy_0 = (curry(function countBy(f, iter) {
  return reduce((counts, a) => incSel(counts, f(a)), {}, iter);
}));
// CONCATENATED MODULE: ./Lazy/keysLazy.js
function *keysLazy(obj) {
  for (const k in obj) yield k;
};
// CONCATENATED MODULE: ./keys.js



function keys(a) {
  return takeAll(keysLazy(a));
}
// CONCATENATED MODULE: ./isUndefined.js
/* harmony default export */ var isUndefined = (a => a === undefined);
// CONCATENATED MODULE: ./constant.js
function constant(a) {
  return _ => a;
}
// CONCATENATED MODULE: ./isIterable.js
function isIterable(a) {
  return a != null && !!a[Symbol.iterator];
}
// CONCATENATED MODULE: ./last.js
function last(arr) {
  return arr[arr.length - 1];
}
// CONCATENATED MODULE: ./uniqueBy.js











const uniqueBy_uniqueBy = curry(function uniqueBy(f, iter) {
  const s = new Set();
  const isObj = !isIterable(iter);
  return go(
    iter,
    isObj ? entriesLazy : identity,
    Lazy_filterLazy(pipe(
      isObj ? last : identity,
      f,
      b => s.has(b) ? false : s.add(b))),
    isObj ? object_object : takeAll);
});

/* harmony default export */ var uniqueBy_0 = (uniqueBy_uniqueBy);
// CONCATENATED MODULE: ./unique.js


function unique(iter) {
  return uniqueBy_0(a => a, iter);
}
// CONCATENATED MODULE: ./indexBy.js



/* harmony default export */ var indexBy_0 = (curry(function indexBy(f, iter) {
  return reduce((obj, a) => (obj[f(a)] = a, obj), {}, iter);
}));
// CONCATENATED MODULE: ./min.js


function min(iter) {
  return minBy_0(a => a, iter);
}
// CONCATENATED MODULE: ./noop.js
function noop() {};
// CONCATENATED MODULE: ./log.js
const { log } = console;

/* harmony default export */ var log_0 = (log);
// CONCATENATED MODULE: ./hi.js



const hi_f = tap(log_0);

function hi(..._) { return hi_f(..._); }
// CONCATENATED MODULE: ./baseExtend.js




function baseExtend(set, obj, objs) {
  const type = typeof obj;
  obj &&
    (type == 'object' || type == 'function') &&
      reduce(reduce(set), obj, Lazy_mapLazy(entriesLazy, objs));
  return obj;
}
// CONCATENATED MODULE: ./extend.js


const setter = (obj, [k, v]) => (obj[k] = v, obj);

function extend(obj, ...objs) {
  return baseExtend(setter, obj, objs);
}
// CONCATENATED MODULE: ./takeWhile.js





/* harmony default export */ var takeWhile_0 = (curry(function takeWhile(f, iter) {
  let res = [];
  iter = toIter(iter);
  return function recur() {
    let cur;
    while (!(cur = iter.next()).done) {
      const a = cur.value;
      const b = go1(a, a => f(a, res));
      if (!b) return res;
      if (b instanceof Promise) {
        return b
          .then(async b => b ? (res.push(await a), recur()) : res)
          .catch(e => e == nop_0 ? recur() : Promise.reject(e));
      }
      res.push(a);
    }
    return res;
  } ();
}));
// CONCATENATED MODULE: ./Lazy/mapEntriesLazy.js




/* harmony default export */ var Lazy_mapEntriesLazy = (curry(function *mapEntriesLazy(f, iter) {
  for (const [k, a] of safety(iter)) yield go1(go1(a, f), b => [k, b]);
}));
// CONCATENATED MODULE: ./mapEntries.js




/* harmony default export */ var mapEntries_0 = (curry(function mapEntries(f, iter) {
  return takeAll(Lazy_mapEntriesLazy(f, iter));
}));
// CONCATENATED MODULE: ./negate.js



function negate(f) {
  return (..._) => go1(f(..._), not);
}
// CONCATENATED MODULE: ./some.js





/* harmony default export */ var some_0 = (curry(function some(f, iter) {
  return go1(take1_0(Lazy_filterLazy(f, iter)), ({length}) => length == 1);
}));
// CONCATENATED MODULE: ./Lazy/flatLazy.js





function flatLazy(iter, depth = 1) {
  const iterStack = [toIter(iter)];
  return {
    next: function recur() {
      const iter = last(iterStack);
      if (!iter) return { done: true };
      const cur = iter.next();
      if (cur.done) {
        iterStack.pop();
        return recur();
      } else if (iterStack.length <= depth && isIterable(cur.value) && typeof cur.value != 'string') {
        iterStack.push(cur.value[Symbol.iterator]());
        return recur();
      } else if (cur.value instanceof Promise) {
        return {
          value: cur.value.then(value => {
            if (iterStack.length > depth || !isIterable(value) || typeof value == 'string') return value;
            const iter = value[Symbol.iterator](), cur = iter.next();
            return cur.done ? Promise.reject(nop_0) : (iterStack.push(iter), cur.value);
          }),
          done: false
        };
      } else {
        return cur;
      }
    },
    [Symbol.iterator]() { return this; }
  };
}
// CONCATENATED MODULE: ./Lazy/deepFlatLazy.js


function deepFlatLazy(iter) {
  return flatLazy(iter, Infinity);
}
// CONCATENATED MODULE: ./deepFlat.js



function deepFlat(iter) {
  return takeAll(deepFlatLazy(iter));
}
// CONCATENATED MODULE: ./flat.js



function flat(iter) {
  return takeAll(flatLazy(iter));
}
// CONCATENATED MODULE: ./findWhere.js




/* harmony default export */ var findWhere_0 = (curry(function findWhere(w, iter) {
  return find_0(isMatch_0(w), iter);
}));
// CONCATENATED MODULE: ./baseSel.js





/* harmony default export */ var baseSel = (sep => curry(function sel(selector, acc) {
  return (
    !selector ?
      acc
    :
    isArray_0(selector) ?
      reduce((acc, selector) => sel(selector, acc), acc, selector)
    :
    typeof selector == 'object' || typeof selector == 'function' ?
      findWhere_0(selector, acc)
    :
    reduce(
      (acc, key, s = key[0]) =>
        !acc ? acc :
        s == '#' ? findWhere_0({ id: key.substr(1) }, acc) :
        s == '[' || s == '{' ? findWhere_0(JSON.parse(key), acc) :
        acc[key],
      acc,
      selector.split(sep))
  );
}));
// CONCATENATED MODULE: ./sortBy.js



/* harmony default export */ var sortBy_0 = (curry(function sortBy(f, arr) {
  return baseSortBy(-1, 1, f, arr);
}));
// CONCATENATED MODULE: ./each.js




/* harmony default export */ var each_0 = (curry(function each(f, iter) {
  return go1(reduce((_, a) => f(a), null, iter), _ => iter);
}));
// CONCATENATED MODULE: ./entries.js



function entries_entries(a) {
  return takeAll(entriesLazy(a));
}
// CONCATENATED MODULE: ./filter.js




/* harmony default export */ var filter_0 = (curry(function filter(f, iter) {
  return takeAll(Lazy_filterLazy(f, iter));
}));
// CONCATENATED MODULE: ./sort.js


function sort_sort(arr) {
  return sortBy_0(a => a, arr);
}
// CONCATENATED MODULE: ./isFunction.js
function isFunction(a) {
  return typeof a == 'function';
}
// CONCATENATED MODULE: ./sel.js


/* harmony default export */ var sel_0 = (baseSel('.'));
// CONCATENATED MODULE: ./has.js


/* harmony default export */ var has = (curry(function has(k, obj) {
  return !!(obj && obj.hasOwnProperty(k));
}));
// CONCATENATED MODULE: ./flatMap.js




/* harmony default export */ var flatMap_0 = (curry(function flatMap(f, iter) {
  return flat(map_0(f, iter));
}));
// CONCATENATED MODULE: ./string.js



const sadd = (a, b) => `${a}${b}`;

function string(iter) {
  return reduce(sadd, iter);
}
// CONCATENATED MODULE: ./strMap.js




/* harmony default export */ var strMap_0 = (curry(function strMap(f, iter) {
  return string(Lazy_mapLazy(f, iter));
}));
// CONCATENATED MODULE: ./reject.js





/* harmony default export */ var reject_0 = (curry(function reject(f, iter) {
  return filter_0(a => go1(f(a), not), iter);
}));
// CONCATENATED MODULE: ./pick.js




/* harmony default export */ var pick_0 = (curry(function pick(ks, obj) {
  return basePick_0(Lazy_filterLazy, ks, obj);
}));
// CONCATENATED MODULE: ./Lazy/dropLazy.js




/* harmony default export */ var Lazy_dropLazy = (curry(function *dropLazy(l, iter) {
  if (l < 1) return yield *safety(iter);
  for (const a of safety(iter)) {
    if (a instanceof Promise) yield a.then(a => l ? (l--, Promise.reject(nop_0)) : a);
    else if (l) { l--; continue; }
    else yield a;
  }
}));
// CONCATENATED MODULE: ./drop.js




/* harmony default export */ var drop_0 = (curry(function drop(l, iter) {
  return takeAll(Lazy_dropLazy(l, iter));
}));
// CONCATENATED MODULE: ./tail.js


function tail(iter) {
  return drop_0(1, iter);
}
// CONCATENATED MODULE: ./takeUntil.js





const takeUntil_takeUntil = curry(function takeUntil(f, iter) {
  let res = [];
  iter = toIter(iter);
  return function recur() {
    let cur;
    while (!(cur = iter.next()).done) {
      const a = cur.value;
      const b = go1(a, a => (res.push(a), f(a, res)));
      if (b instanceof Promise)
        return b.then(b => b ? res : recur()).catch(e => e == nop_0 ? recur() : Promise.reject(e));
      if (b) break;
    }
    return res;
  } ();
});

/* harmony default export */ var takeUntil_0 = (takeUntil_takeUntil);
// CONCATENATED MODULE: ./defaults.js



const defaults_setter = (obj, [k, v]) => {
  return (has(k, obj) || (obj[k] = v, obj), obj);
};

function defaults(obj, ...objs) {
  return baseExtend(defaults_setter, obj, objs);
}

/* harmony default export */ var defaults_0 = (defaults);
// CONCATENATED MODULE: ./baseCalls.js




const baseCalls = (map, object) => function calls(fs, ...args) {
  return isIterable(fs) ?
    map(f => f(...args), fs) :
    object(Lazy_mapEntriesLazy(f => f(...args), entriesLazy(fs)));
};

/* harmony default export */ var baseCalls_0 = (baseCalls);
// CONCATENATED MODULE: ./calls.js




/* harmony default export */ var calls_0 = (baseCalls_0(map_0, object_object));
// CONCATENATED MODULE: ./delay.js


/* harmony default export */ var delay = (curry(function delay(time, a) {
  return new Promise(resolve => setTimeout(() => resolve(a), time));
}));
// CONCATENATED MODULE: ./mapObject.js





/* harmony default export */ var mapObject_0 = (curry(function mapObject(f, obj) {
  return object_object(Lazy_mapEntriesLazy(f, entriesLazy(obj)));
}));
// CONCATENATED MODULE: ./promiseAllObject.js



function promiseAllObject(obj) {
  return mapObject_0(identity, obj);
}
// CONCATENATED MODULE: ./promiseAllEntries.js



function promiseAllEntries(entries) {
  return mapEntries_0(identity, entries);
}
// CONCATENATED MODULE: ./Lazy/rangeLazy.js
function *rangeLazy(start = 0, stop = start, step = 1) {
  if (arguments.length == 1) start = 0;
  while (start < stop) {
    yield start;
    start += step;
  }
}
// CONCATENATED MODULE: ./range.js



function range(..._) {
  return takeAll(rangeLazy(..._));
}
// CONCATENATED MODULE: ./dropRight.js





/* harmony default export */ var dropRight = (curry(function drop(l, iter) {
  return go1(takeAll(iter), arr => take_0(arr.length - l, arr));
}));
// CONCATENATED MODULE: ./Lazy/flatMapLazy.js




/* harmony default export */ var Lazy_flatMapLazy = (curry(function flatMapLazy(f, iter) {
  return flatLazy(Lazy_mapLazy(f, iter));
}));
// CONCATENATED MODULE: ./Lazy/headTailLazy.js




function headTailLazy(iter) {
  return go1(take_0(1, iter = toIter(iter)), ([head]) => [head, iter]);
}
// CONCATENATED MODULE: ./Lazy/indexValuesLazy.js


function *indexValuesLazy(iter) {
  let i = -1;
  for (const a of safety(iter)) yield [++i, a];
};
// CONCATENATED MODULE: ./Lazy/reverseLazy.js
function *reverseLazy(arr) {
  var l = arr.length;
  while (l--) yield arr[l];
}
// CONCATENATED MODULE: ./Lazy/takeLazy.js



/* harmony default export */ var Lazy_takeLazy = (curry(function *takeLazy(l, iter) {
  if (l < 1) return;
  for (const a of safety(iter)) {
    if (a instanceof Promise) yield a.then(a => (--l, a));
    else yield (--l, a);
    if (!l) break;
  }
}));
// CONCATENATED MODULE: ./Lazy/takeWhileLazy.js





/* harmony default export */ var Lazy_takeWhileLazy = (curry(function *takeWhileLazy(f, iter) {
  let ok = false;
  for (const a of safety(iter)) {
    ok = go1(a, f);
    if (ok instanceof Promise) yield ok.then(_ok => (ok = _ok) ? a : Promise.reject(nop_0));
    else if (ok) yield a;
    if (!ok) break;
  }
}));
// CONCATENATED MODULE: ./Lazy/takeUntilLazy.js




/* harmony default export */ var Lazy_takeUntilLazy = (curry(function *takeUntilLazy(f, iter) {
  let ok = false;
  for (const a of safety(iter)) {
    ok = go1(a, f);
    if (ok instanceof Promise) yield ok.then(_ok => ((ok = _ok), a));
    else yield a;
    if (ok) break;
  }
}));
// CONCATENATED MODULE: ./Lazy/intervalLazy.js




function intervalLazy(time) {
  return Lazy_mapLazy(delay(time), rangeLazy(Infinity));
}
// CONCATENATED MODULE: ./L.js




















const L = {
  deepFlat: deepFlatLazy,
  deep_flat: deepFlatLazy,
  deepFlatten: deepFlatLazy,
  deep_flatten: deepFlatLazy,
  entries: entriesLazy,
  entriesMap: Lazy_mapEntriesLazy,
  entries_map: Lazy_mapEntriesLazy,
  mapEntries: Lazy_mapEntriesLazy,
  map_entries: Lazy_mapEntriesLazy,
  filter: Lazy_filterLazy,
  flat: flatLazy,
  flatMap: Lazy_flatMapLazy,
  flat_map: Lazy_flatMapLazy,
  headTail: headTailLazy,
  indexValues: indexValuesLazy,
  index_values: indexValuesLazy,
  keys: keysLazy,
  map: Lazy_mapLazy,
  range: rangeLazy,
  reject: Lazy_rejectLazy,
  reverse: reverseLazy,
  values: valuesLazy,
  take: Lazy_takeLazy,
  takeWhile: Lazy_takeWhileLazy,
  take_while: Lazy_takeWhileLazy,
  takeUntil: Lazy_takeUntilLazy,
  take_until: Lazy_takeUntilLazy,
  interval: intervalLazy,
  drop: Lazy_dropLazy
};


// CONCATENATED MODULE: ./Concurrency/catchNoop.js
function catchNoop(arr) {
  arr.forEach(a => a instanceof Promise ? a.catch(function() {}) : a);
  return arr;
}

/* harmony default export */ var Concurrency_catchNoop = (catchNoop);
// CONCATENATED MODULE: ./Concurrency/dropC.js




/* harmony default export */ var Concurrency_dropC = (curry(function dropC(l, iter) {
  return drop_0(l, Concurrency_catchNoop([...iter]));
}));
// CONCATENATED MODULE: ./Concurrency/tailC.js


function tailC(iter) {
  return Concurrency_dropC(1, iter);
}
// CONCATENATED MODULE: ./Concurrency/reduceC.js




/* harmony default export */ var Concurrency_reduceC = (curry(function reduceC(f, acc, iter) {
  return arguments.length == 2 ?
    reduce(f, Concurrency_catchNoop([...acc])) :
    reduce(f, acc, Concurrency_catchNoop([...iter]));
}));
// CONCATENATED MODULE: ./Concurrency/takeC.js




/* harmony default export */ var Concurrency_takeC = (curry(function takeC(l, iter) {
  return take_0(l, Concurrency_catchNoop([...iter]));
}));
// CONCATENATED MODULE: ./Concurrency/takeAllC.js


/* harmony default export */ var takeAllC = (Concurrency_takeC(Infinity));
// CONCATENATED MODULE: ./Concurrency/mapEntriesC.js




/* harmony default export */ var Concurrency_mapEntriesC = (curry(async function mapEntriesC(f, iter) {
  return takeAllC(Lazy_mapEntriesLazy(f, iter));
}));
// CONCATENATED MODULE: ./Concurrency/headC.js



function headC(iter) {
  return go1(Concurrency_takeC(1, iter), ([h]) => h);
}
// CONCATENATED MODULE: ./Concurrency/findC.js




/* harmony default export */ var Concurrency_findC = (curry(function findC(f, iter) {
  return headC(Lazy_filterLazy(f, iter));
}));
// CONCATENATED MODULE: ./Concurrency/mapC.js




/* harmony default export */ var Concurrency_mapC = (curry(function mapC(f, iter) {
  return takeAllC(Lazy_mapLazy(f, iter));
}));
// CONCATENATED MODULE: ./Concurrency/take1C.js


/* harmony default export */ var take1C = (Concurrency_takeC(1));
// CONCATENATED MODULE: ./Concurrency/everyC.js





/* harmony default export */ var Concurrency_everyC = (curry(function everyC(f, iter) {
  return go1(take1C(Lazy_rejectLazy(f, iter)), ({length}) => length == 0);
}));;
// CONCATENATED MODULE: ./Concurrency/filterC.js




/* harmony default export */ var Concurrency_filterC = (curry(function filterC(f, iter) {
  return takeAllC(Lazy_filterLazy(f, iter));
}));
// CONCATENATED MODULE: ./Concurrency/objectC.js


function objectC(iter) {
  return Concurrency_reduceC((obj, [k, v]) => (obj[k] = v, obj), {}, iter);
}
// CONCATENATED MODULE: ./Concurrency/callsC.js




/* harmony default export */ var callsC = (baseCalls_0(Concurrency_mapC, objectC));
// CONCATENATED MODULE: ./Concurrency/someC.js





/* harmony default export */ var Concurrency_someC = (curry(function someC(f, iter) {
  return go1(take1C(Lazy_filterLazy(f, iter)), ({length}) => length == 1);
}));
// CONCATENATED MODULE: ./C.js















const C = {
  tail: tailC,
  reduce: Concurrency_reduceC,
  take: Concurrency_takeC,
  mapEntries: Concurrency_mapEntriesC,
  map_entries: Concurrency_mapEntriesC,
  entriesMap: Concurrency_mapEntriesC,
  entries_map: Concurrency_mapEntriesC,
  find: Concurrency_findC,
  map: Concurrency_mapC,
  every: Concurrency_everyC,
  filter: Concurrency_filterC,
  takeAll: takeAllC,
  take_all: takeAllC,
  head: headC,
  take1: take1C,
  calls: callsC,
  some: Concurrency_someC,
  drop: Concurrency_dropC
};


// CONCATENATED MODULE: ./fx-browser.js

























































































window.fx = window._ = {};
window.fx.L = window.L = L_namespaceObject.L;
window.fx.C = window.C = C_namespaceObject.C;

_.minBy = _.min_by = minBy_0;
_.sortDesc = _.sort_desc = sort;
_.go = go;
_.goS = goS;
_.identity = identity;
_.reduce = reduce;
_.reduceS = reduceS;
_.stop = stop;
_.stopIf = _.stop_if = stopIf;
_.take = take_0;
_.omit = omit_0;
_.values = values;
_.groupBy = _.group_by = groupBy_0;
_.tap = tap;
_.pipe = pipe;
_.pipeS = pipeS;
_.isString = _.is_string = isString;
_.max = max;
_.pluck = pluck_0;
_.takeAll = _.take_all = takeAll;
_.countBy = _.count_by = countBy_0;
_.keys = keys;
_.isUndefined = _.is_undefined = isUndefined;
_.constant = constant;
_.unique = _.uniq = unique;
_.indexBy = _.index_by = indexBy_0;
_.min = min;
_.sortByDesc = _.sort_by_desc = sortByDesc_0;
_.noop = noop;
_.hi = hi;
_.extend = extend;
_.empty = empty;
_.takeWhile = _.take_while = takeWhile_0;
_.isMatch = _.is_match = isMatch_0;
_.mapEntries = _.map_entries = _.entriesMap = _.entries_map = mapEntries_0;
_.object = object_object;
_.negate = negate;
_.nop = nop_0;
_.call = call;
_.some = some_0;
_.deepFlat = _.deepFlatten = _.deep_flat = _.deep_flatten = deepFlat;
_.toIter = _.to_iter = toIter;
_.maxBy = _.max_by = maxBy_0;
_.flat = _.flatten = flat;
_.baseSel = _.base_sel = baseSel;
_.sortBy = _.sort_by = sortBy_0;
_.not = not;
_.go1 = go1;
_.find = find_0;
_.isArray = _.is_array = isArray_0;
_.each = each_0;
_.entries = entries_entries;
_.filter = filter_0;
_.sort = sort_sort;
_.curry = curry;
_.isFunction = _.is_function = isFunction;
_.sel = sel_0;
_.match = match_0;
_.map = map_0;
_.head = head;
_.every = every_0;
_.has = has;
_.isIterable = _.is_iterable = isIterable;
_.uniqueBy = _.unique_by = uniqueBy_0;
_.flatMap = _.flat_map = flatMap_0;
_.string = string;
_.strMap = _.str_map = _.scat = strMap_0;
_.findWhere = _.find_where = findWhere_0;
_.reject = reject_0;
_.pick = pick_0;
_.last = last;
_.take1 = take1_0;
_.tail = tail;
_.log = log_0;
_.takeUntil = _.take_until = takeUntil_0;
_.defaults = defaults_0;
_.calls = calls_0;
_.delay = delay;
_.safety = safety;
_.mapObject = _.map_object = mapObject_0;
_.promiseAllObject = _.promise_all_object = promiseAllObject;
_.promiseAllEntries = _.promise_all_entries = promiseAllEntries;
_.isStop = _.is_stop = isStop;
_.range = range;
_.drop = drop_0;
_.dropRight = _.drop_right = dropRight;

/***/ })
/******/ ]);
//# sourceMappingURL=fx.js.map