3

├── README.md ├── 3.html ├── fx.js ├── 4.html ├── 1.html ├── 2.html ├── 5.html └── fx.0.10.1.js /README.md: -------------------------------------------------------------------------------- 1 | # 11번가 함수형 프로그래밍, ES6+ 강의 2 | 3 | 1. ES6+ 기본기 4 | - 이터러블 5 | - for...of 가 내부적으로 하는 일 6 | - 이터레이터 7 | - 제너레이터 8 | 2. map, filter 9 | - map 10 | - filter 11 | 3. 이터러블 프로토콜로 다시 만들기 12 | - L.map 13 | - L.filter 14 | - L.take 15 | - L.takeUntil 16 | 4. 지연 평가와 제너레이터 17 | - range 18 | - 동작 순서와 효율 19 | 5. 명령형을 이터러블 프로그래밍으로 전환 1 20 | - 홀수 n개 더하기 명령형 코드 21 | - if를 filter로 22 | - 값 변화 후 변수 할당을 map으로 23 | - break를 take로 24 | - 합산을 reduce로 25 | - 효율 비교 26 | 6. 축약하는 함수 reduce 27 | - reduce, add 28 | - count 29 | 7. 함수를 다루는 함수 30 | - go 31 | - pipe 32 | - curry 33 | 8. 2차원 배열 다루기 flat 34 | - L.flat 35 | - 리얼월드, users 36 | 9. 커머스 데이터 다루기 37 | - 간단한 장바구니 38 | - 복잡한 장바구니 39 | 10. 비동기/동시성 프로그래밍 40 | - 비동기를 값으로 만드는 Promise 41 | - 값으로서의 Promise 활용 42 | - 합성 관점에서의 Promise 43 | - go, pipe, reduce에서 비동기 제어 44 | 11. 시간을 이터러블로 다루기 45 | 12. 아임포트 결제 누락 처리 스케쥴러 만들기 46 | 13. 이터러블 프로그래밍을 익혀야 하는 이유 -------------------------------------------------------------------------------- /3.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 3 6 | 7 | 8 | 9 | 10 | 11 | 10. 비동기/동시성 프로그래밍 12 | - callback과 Promise 13 | 35 | 36 | - 비동기를 값으로 만드는 Promise 37 | - 값으로서의 Promise 활용 38 | 50 | 51 | - 합성 관점에서의 Promise 52 | 61 | 62 | - go, pipe, reduce에서 비동기 제어 63 | 76 | 77 | 78 | -------------------------------------------------------------------------------- /fx.js: -------------------------------------------------------------------------------- 1 | const curry = f => (a, ...rest) => 2 | rest.length ? 3 | f(a, ...rest) : 4 | (...rest) => f(a, ...rest); 5 | 6 | const L = {}; 7 | L.map = curry(function* (f, iter) { 8 | for (const a of iter) { 9 | yield f(a); 10 | } 11 | }); 12 | 13 | const map = curry((..._) => [...L.map(..._)]); 14 | 15 | L.filter = curry(function* (f, iter) { 16 | for (const a of iter) { 17 | if (f(a)) yield a; 18 | } 19 | }); 20 | const filter = curry((..._) => [...L.filter(..._)]); 21 | 22 | L.takeUntil = curry(function* (f, iter) { 23 | for (const a of iter) { 24 | yield a; 25 | if (f(a)) break; 26 | } 27 | }); 28 | 29 | const takeUntil = curry((..._) => [...L.takeUntil(..._)]); 30 | 31 | L.take = curry((limit, iter) => L.takeUntil(_ => --limit == 0, iter)); 32 | 33 | const take = curry((..._) => [...L.take(..._)]); 34 | 35 | L.range = function* (start, end, step = 1) { 36 | while (start < end) { 37 | yield start; 38 | start += step; 39 | } 40 | }; 41 | 42 | const range = (..._) => [...L.range(..._)]; 43 | 44 | const go1 = (a, f) => 45 | a instanceof Promise ? a.then(f) : f(a); 46 | 47 | const reduce = curry(function(f, acc, iter) { 48 | if (arguments.length == 2) { 49 | iter = acc[Symbol.iterator](); 50 | acc = iter.next().value; 51 | } 52 | for (let a of iter) { 53 | acc = go1(acc, acc => f(acc, a)); 54 | } 55 | return acc; 56 | }); 57 | 58 | const add = (a, b) => a + b; 59 | 60 | const go = (arg, ...fs) => 61 | reduce((arg, f) => f(arg), arg, fs); 62 | 63 | const pipe = (f, ...fs) => (...args) => go(f(...args), ...fs); 64 | 65 | const sum = reduce(add); 66 | 67 | const sumBy = curry((f, iter) => sum(map(f, iter))); 68 | 69 | const isIterable = a => Boolean(a && a[Symbol.iterator]); 70 | 71 | L.flat = function* (iter) { 72 | for (const a of iter) { 73 | if (isIterable(a)) { 74 | yield* a; 75 | } else { 76 | yield a; 77 | } 78 | } 79 | }; 80 | 81 | const flat = iter => [...L.flat(iter)]; -------------------------------------------------------------------------------- /4.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 4 6 | 7 | 8 | 11 | 12 | 13 | 14 | 11. 시간을 이터러블로 다루기 15 | 17 | 18 | 12. 아임포트 결제 누락 처리 스케쥴러 만들기 19 | - https://github.com/iamport/iamport-manual/blob/master/%EC%9D%B8%EC%A6%9D%EA%B2%B0%EC%A0%9C/README.md#23-notification-url%EA%B0%80%EC%83%81%EA%B3%84%EC%A2%8C-%EC%9E%85%EA%B8%88%ED%86%B5%EB%B3%B4-%ED%8F%AC%ED%95%A8 20 | - https://api.iamport.kr/ 21 | 22 | 102 | 103 | 104 | -------------------------------------------------------------------------------- /1.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 1 6 | 7 | 8 | 9 | 10 | 11 | 1. ES6+ 기본기 12 | 13 | - 이터러블 14 | - 순회 가능한 값. 15 | - iterable[Symbol.iterator]()로 이터레이터를 리턴하는 값. 16 | - 이터레이터 17 | - iterator.next()가 { value: Any, done: Boolean }를 리턴하는 값 18 | - rangeIterator 19 | 40 | 41 | - for...of 가 내부적으로 하는 일 42 | 53 | 54 | - 제너레이터 55 | - 실행하면 이터레이터를 반환하는 함수 56 | - yield 로 next()의 value 값을 발생 57 | - return 을 하면 { done: true } 58 | 74 | 75 | 2. map, filter 76 | - map 77 | - filter 78 | 99 | 100 | 3. 이터러블 프로토콜로 다시 만들기 101 | - L.map 102 | - L.filter 103 | - L.take 104 | - L.takeUntil 105 | - L.range 106 | 145 | 146 | 4. 지연 평가와 제너레이터 147 | - 동작 순서와 효율 148 | 163 | 164 | 5. 명령형을 이터러블 프로그래밍으로 전환 1 165 | - 홀수 n개 더하기 명령형 코드 166 | 190 | 191 | 192 | -------------------------------------------------------------------------------- /2.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 2 6 | 7 | 8 | 9 | 10 | 11 | 6. 축약하는 함수 reduce 12 | - reduce, add 13 | 17 | 18 | - count 19 | 30 | 31 | 7. 함수를 다루는 함수 32 | - go 33 | - pipe (첫 번째 함수는 인자 여러개 받도록) 34 | 64 | 65 | - curry 66 | 93 | 94 | 8. 2차원 배열 다루기 flat 95 | - L.flat 96 | 122 | 123 | - 리얼월드, users 124 | 154 | 155 | 9. 커머스 데이터 다루기 156 | - 간단한 장바구니 157 | 193 | 194 | - 복잡한 장바구니 195 | 261 | 262 | 263 | -------------------------------------------------------------------------------- /5.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 4 6 | 7 | 8 | 37 | 38 | 39 | 40 | 13. 이터러블 프로그래밍을 익혀야 하는 이유 41 | 42 | # ES6+의 표준 프로토콜 43 | - for...of 문은 이터러블을 순회합니다. 44 | 50 | 51 | - 이터러블은 전개 연산자를 통해 펼칠 수 있습니다. 52 | 56 | 57 | - [] 를 통한 구조분해는 이터러블에 사용합니다. 58 | 63 | 64 | - 나머지 연산자도 이터러블에 사용합니다. 65 | 70 | 71 | - 이터러블은 [Symbol.iterator]()를 통해 이터레이터를 반환합니다. 72 | - 제너레이터는 이터레이터를 반환합니다. 73 | - 이터레이터는 곧 이터러블입니다. (well-formed) 74 | - 이터레이터/제너레이터는 자바스크립트의 연산자, 구문 등과 함께 동작합니다. 75 | 94 | 95 | - 이런 규약을 통칭해 이터러블 프로토콜이라고 하며 이것은 ES6에서 매우 중요한 위치에 있습니다. 96 | - ES6+ 에서도 이런 규약을 사용하거나 컨셉을 함께하는 규약들이 만들어지고 있습니다. 97 | 98 | # 프로그래밍 패러다임 99 | - 이터러블/이터레이터/제너레이터는 코드를 값으로 다룰 수 있도록 하는 도구입니다. 100 | 136 | 137 | - 코드를 값으로 다루는 것은 리습/메타프로그래밍의 핵심입니다. 138 | - 자바스크립트는 이제 공식적으로 코드, 로직, 상태, 에러를 '값'으로 다룰 수 있게 되었습니다. 139 | - 비동기/동시성/병렬성을 값으로 잘 다룰 수 있습니다. 140 | - 함수와 코드를 값으로 다루는 것은 일종의 프로그래밍 패러다임입니다. 141 | - 이터러블 프로토콜을 잘 다룬다는 것은 새로운 프로그래밍 패러다임을 익히는 것과 같습니다. 142 | - 새로운 프로그래밍 패러다임을 익히는 것은 언어에 대한 관점과 응용력을 확장하는 것입니다. 143 | - 언어에 대한 응용력이 좋아지면 문제 해결력, 생산성, 안정성이 좋아집니다. 144 | - 문제 해결, 생산성, 안정성은 성공적인 프로그래밍의 핵심적인 지표입니다. 145 | - 현대 프로그래밍에서 함수형 패러다임은 언어 제약적이지 않습니다. 146 | 147 | # 조합성, 재사용성 148 | - 코드가 값으로 다뤄 질수 있다는 것은 그 코드가 어떤 '규약'을 지키고 있다는 것입니다. 149 | - 값으로 다룰 수 있도록 규약이 지켜진 코드는 재사용성이 높습니다. 150 | - 규약이 지켜진 코드는 다른 코드와의 조합성이 높습니다. 151 | - 규약이 지켜진 코드는 협업을 용이하게 합니다. 152 | - 이 규약이 언어의 규약과 일치할 수록 언어와 여러 도구의 도움을 받기 용이합니다. 153 | 154 | # 응용력 155 | - 추상화가 잘 된 규약은 응용력이 높습니다. 156 | - 이터러블은 값을 계산하여 세분화해나간 후에도 이터러블인 상태를 유지하도록 하여 157 | 추상화 수준을 동일하게 유지하는 아이디어를 가지고 있습니다. 158 | 166 | 167 | - 추상화 단계가 유지되면 여전히 동일한 응용력을 가질 수 있습니다. 168 | 182 | 183 | - 일반화가 많이 된 규약은 특정 상황에만 잘 대응될 가능성이 높습니다. 184 | - 소프트웨어의 복잡성이 증가할 수록 특정 상황에 특화된 패러다임보다는 185 | 유연성과 생산성을 함께 높일 수 있는 패러다임이 유리합니다. 186 | 187 | # 명령형 vs 함수형 188 | - 명령형 코드는 서로의 코드를 이해하기 어렵습니다. 189 | 203 | 204 | - 함수형 코드는 이해하기 쉬울 뿐 아니라 '코드를 응용(Applicative)' 할 수 있습니다. 205 | 214 | 215 | - 함수형 코드는 어디에서든 쓰일 수 있습니다. 216 | 217 | 231 | 232 | # 결론 233 | - '이터러블 프로그래밍'이라는 규약을 중심에 두고 팀 작업을 하게 되면, 234 | 구성원 간에 같은 관점을 갖게하여 소통이 용이하며, 235 | 생산성, 조합성, 안정성, 코드 품질 관리의 객관성을 높일 수 있습니다. 236 | - 팀에서 공유하고 있는 패러다임이 성숙해질수록 높을 효율을 얻을 수 있습니다. 237 | 238 | 239 | -------------------------------------------------------------------------------- /fx.0.10.1.js: -------------------------------------------------------------------------------- 1 | /******/ (function(modules) { // webpackBootstrap 2 | /******/ // The module cache 3 | /******/ var installedModules = {}; 4 | /******/ 5 | /******/ // The require function 6 | /******/ function __webpack_require__(moduleId) { 7 | /******/ 8 | /******/ // Check if module is in cache 9 | /******/ if(installedModules[moduleId]) { 10 | /******/ return installedModules[moduleId].exports; 11 | /******/ } 12 | /******/ // Create a new module (and put it into the cache) 13 | /******/ var module = installedModules[moduleId] = { 14 | /******/ i: moduleId, 15 | /******/ l: false, 16 | /******/ exports: {} 17 | /******/ }; 18 | /******/ 19 | /******/ // Execute the module function 20 | /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); 21 | /******/ 22 | /******/ // Flag the module as loaded 23 | /******/ module.l = true; 24 | /******/ 25 | /******/ // Return the exports of the module 26 | /******/ return module.exports; 27 | /******/ } 28 | /******/ 29 | /******/ 30 | /******/ // expose the modules object (__webpack_modules__) 31 | /******/ __webpack_require__.m = modules; 32 | /******/ 33 | /******/ // expose the module cache 34 | /******/ __webpack_require__.c = installedModules; 35 | /******/ 36 | /******/ // define getter function for harmony exports 37 | /******/ __webpack_require__.d = function(exports, name, getter) { 38 | /******/ if(!__webpack_require__.o(exports, name)) { 39 | /******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); 40 | /******/ } 41 | /******/ }; 42 | /******/ 43 | /******/ // define __esModule on exports 44 | /******/ __webpack_require__.r = function(exports) { 45 | /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 46 | /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 47 | /******/ } 48 | /******/ Object.defineProperty(exports, '__esModule', { value: true }); 49 | /******/ }; 50 | /******/ 51 | /******/ // create a fake namespace object 52 | /******/ // mode & 1: value is a module id, require it 53 | /******/ // mode & 2: merge all properties of value into the ns 54 | /******/ // mode & 4: return value when already ns object 55 | /******/ // mode & 8|1: behave like require 56 | /******/ __webpack_require__.t = function(value, mode) { 57 | /******/ if(mode & 1) value = __webpack_require__(value); 58 | /******/ if(mode & 8) return value; 59 | /******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; 60 | /******/ var ns = Object.create(null); 61 | /******/ __webpack_require__.r(ns); 62 | /******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); 63 | /******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); 64 | /******/ return ns; 65 | /******/ }; 66 | /******/ 67 | /******/ // getDefaultExport function for compatibility with non-harmony modules 68 | /******/ __webpack_require__.n = function(module) { 69 | /******/ var getter = module && module.__esModule ? 70 | /******/ function getDefault() { return module['default']; } : 71 | /******/ function getModuleExports() { return module; }; 72 | /******/ __webpack_require__.d(getter, 'a', getter); 73 | /******/ return getter; 74 | /******/ }; 75 | /******/ 76 | /******/ // Object.prototype.hasOwnProperty.call 77 | /******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; 78 | /******/ 79 | /******/ // __webpack_public_path__ 80 | /******/ __webpack_require__.p = ""; 81 | /******/ 82 | /******/ 83 | /******/ // Load entry module and return exports 84 | /******/ return __webpack_require__(__webpack_require__.s = 0); 85 | /******/ }) 86 | /************************************************************************/ 87 | /******/ ([ 88 | /* 0 */ 89 | /***/ (function(module, __webpack_exports__, __webpack_require__) { 90 | 91 | "use strict"; 92 | __webpack_require__.r(__webpack_exports__); 93 | var Strict_namespaceObject = {}; 94 | __webpack_require__.r(Strict_namespaceObject); 95 | __webpack_require__.d(Strict_namespaceObject, "add", function() { return add; }); 96 | __webpack_require__.d(Strict_namespaceObject, "append", function() { return Strict_append; }); 97 | __webpack_require__.d(Strict_namespaceObject, "apply", function() { return apply; }); 98 | __webpack_require__.d(Strict_namespaceObject, "baseSel", function() { return baseSel; }); 99 | __webpack_require__.d(Strict_namespaceObject, "base_sel", function() { return baseSel; }); 100 | __webpack_require__.d(Strict_namespaceObject, "call", function() { return call; }); 101 | __webpack_require__.d(Strict_namespaceObject, "calls", function() { return Strict_calls; }); 102 | __webpack_require__.d(Strict_namespaceObject, "chunk", function() { return Strict_chunk; }); 103 | __webpack_require__.d(Strict_namespaceObject, "compact", function() { return compact; }); 104 | __webpack_require__.d(Strict_namespaceObject, "constant", function() { return constant; }); 105 | __webpack_require__.d(Strict_namespaceObject, "countBy", function() { return Strict_countBy; }); 106 | __webpack_require__.d(Strict_namespaceObject, "count_by", function() { return Strict_countBy; }); 107 | __webpack_require__.d(Strict_namespaceObject, "curry", function() { return curry; }); 108 | __webpack_require__.d(Strict_namespaceObject, "debounce", function() { return Strict_debounce; }); 109 | __webpack_require__.d(Strict_namespaceObject, "deepFlat", function() { return deepFlat; }); 110 | __webpack_require__.d(Strict_namespaceObject, "deepFlatten", function() { return deepFlat; }); 111 | __webpack_require__.d(Strict_namespaceObject, "deep_flat", function() { return deepFlat; }); 112 | __webpack_require__.d(Strict_namespaceObject, "deep_flatten", function() { return deepFlat; }); 113 | __webpack_require__.d(Strict_namespaceObject, "defaults", function() { return Strict_defaults; }); 114 | __webpack_require__.d(Strict_namespaceObject, "defaultTo", function() { return defaultTo; }); 115 | __webpack_require__.d(Strict_namespaceObject, "default_to", function() { return defaultTo; }); 116 | __webpack_require__.d(Strict_namespaceObject, "delay", function() { return delay; }); 117 | __webpack_require__.d(Strict_namespaceObject, "difference", function() { return Strict_difference; }); 118 | __webpack_require__.d(Strict_namespaceObject, "differenceBy", function() { return Strict_differenceBy; }); 119 | __webpack_require__.d(Strict_namespaceObject, "difference_by", function() { return Strict_differenceBy; }); 120 | __webpack_require__.d(Strict_namespaceObject, "differenceWith", function() { return Strict_differenceWith; }); 121 | __webpack_require__.d(Strict_namespaceObject, "difference_with", function() { return Strict_differenceWith; }); 122 | __webpack_require__.d(Strict_namespaceObject, "drop", function() { return Strict_drop; }); 123 | __webpack_require__.d(Strict_namespaceObject, "dropRight", function() { return dropRight; }); 124 | __webpack_require__.d(Strict_namespaceObject, "drop_right", function() { return dropRight; }); 125 | __webpack_require__.d(Strict_namespaceObject, "dropUntil", function() { return dropUntil; }); 126 | __webpack_require__.d(Strict_namespaceObject, "drop_until", function() { return dropUntil; }); 127 | __webpack_require__.d(Strict_namespaceObject, "dropWhile", function() { return Strict_dropWhile; }); 128 | __webpack_require__.d(Strict_namespaceObject, "drop_while", function() { return Strict_dropWhile; }); 129 | __webpack_require__.d(Strict_namespaceObject, "each", function() { return Strict_each; }); 130 | __webpack_require__.d(Strict_namespaceObject, "forEach", function() { return Strict_each; }); 131 | __webpack_require__.d(Strict_namespaceObject, "entries", function() { return entries_entries; }); 132 | __webpack_require__.d(Strict_namespaceObject, "every", function() { return Strict_every; }); 133 | __webpack_require__.d(Strict_namespaceObject, "extend", function() { return extend; }); 134 | __webpack_require__.d(Strict_namespaceObject, "filter", function() { return Strict_filter; }); 135 | __webpack_require__.d(Strict_namespaceObject, "find", function() { return Strict_find; }); 136 | __webpack_require__.d(Strict_namespaceObject, "findWhere", function() { return Strict_findWhere; }); 137 | __webpack_require__.d(Strict_namespaceObject, "find_where", function() { return Strict_findWhere; }); 138 | __webpack_require__.d(Strict_namespaceObject, "flat", function() { return flat; }); 139 | __webpack_require__.d(Strict_namespaceObject, "flatten", function() { return flat; }); 140 | __webpack_require__.d(Strict_namespaceObject, "flatMap", function() { return Strict_flatMap; }); 141 | __webpack_require__.d(Strict_namespaceObject, "flat_map", function() { return Strict_flatMap; }); 142 | __webpack_require__.d(Strict_namespaceObject, "go", function() { return go; }); 143 | __webpack_require__.d(Strict_namespaceObject, "go1", function() { return go1; }); 144 | __webpack_require__.d(Strict_namespaceObject, "goS", function() { return goS; }); 145 | __webpack_require__.d(Strict_namespaceObject, "groupBy", function() { return Strict_groupBy; }); 146 | __webpack_require__.d(Strict_namespaceObject, "group_by", function() { return Strict_groupBy; }); 147 | __webpack_require__.d(Strict_namespaceObject, "has", function() { return has; }); 148 | __webpack_require__.d(Strict_namespaceObject, "head", function() { return head; }); 149 | __webpack_require__.d(Strict_namespaceObject, "hi", function() { return hi; }); 150 | __webpack_require__.d(Strict_namespaceObject, "html", function() { return html; }); 151 | __webpack_require__.d(Strict_namespaceObject, "identity", function() { return identity; }); 152 | __webpack_require__.d(Strict_namespaceObject, "indexBy", function() { return Strict_indexBy; }); 153 | __webpack_require__.d(Strict_namespaceObject, "index_by", function() { return Strict_indexBy; }); 154 | __webpack_require__.d(Strict_namespaceObject, "initial", function() { return initial; }); 155 | __webpack_require__.d(Strict_namespaceObject, "intersection", function() { return Strict_intersection; }); 156 | __webpack_require__.d(Strict_namespaceObject, "intersectionBy", function() { return Strict_intersectionBy; }); 157 | __webpack_require__.d(Strict_namespaceObject, "intersection_by", function() { return Strict_intersectionBy; }); 158 | __webpack_require__.d(Strict_namespaceObject, "intersectionWith", function() { return Strict_intersectionWith; }); 159 | __webpack_require__.d(Strict_namespaceObject, "intersection_with", function() { return Strict_intersectionWith; }); 160 | __webpack_require__.d(Strict_namespaceObject, "isArray", function() { return Strict_isArray; }); 161 | __webpack_require__.d(Strict_namespaceObject, "is_array", function() { return Strict_isArray; }); 162 | __webpack_require__.d(Strict_namespaceObject, "isFunction", function() { return isFunction; }); 163 | __webpack_require__.d(Strict_namespaceObject, "is_function", function() { return isFunction; }); 164 | __webpack_require__.d(Strict_namespaceObject, "isIterable", function() { return isIterable; }); 165 | __webpack_require__.d(Strict_namespaceObject, "is_iterable", function() { return isIterable; }); 166 | __webpack_require__.d(Strict_namespaceObject, "isMatch", function() { return Strict_isMatch; }); 167 | __webpack_require__.d(Strict_namespaceObject, "is_match", function() { return Strict_isMatch; }); 168 | __webpack_require__.d(Strict_namespaceObject, "isStop", function() { return isStop; }); 169 | __webpack_require__.d(Strict_namespaceObject, "is_stop", function() { return isStop; }); 170 | __webpack_require__.d(Strict_namespaceObject, "isString", function() { return isString; }); 171 | __webpack_require__.d(Strict_namespaceObject, "is_string", function() { return isString; }); 172 | __webpack_require__.d(Strict_namespaceObject, "isUndefined", function() { return isUndefined; }); 173 | __webpack_require__.d(Strict_namespaceObject, "is_undefined", function() { return isUndefined; }); 174 | __webpack_require__.d(Strict_namespaceObject, "join", function() { return Strict_join; }); 175 | __webpack_require__.d(Strict_namespaceObject, "keys", function() { return keys; }); 176 | __webpack_require__.d(Strict_namespaceObject, "last", function() { return last; }); 177 | __webpack_require__.d(Strict_namespaceObject, "log", function() { return Strict_log; }); 178 | __webpack_require__.d(Strict_namespaceObject, "map", function() { return Strict_map; }); 179 | __webpack_require__.d(Strict_namespaceObject, "mapEntries", function() { return Strict_mapEntries; }); 180 | __webpack_require__.d(Strict_namespaceObject, "map_entries", function() { return Strict_mapEntries; }); 181 | __webpack_require__.d(Strict_namespaceObject, "entriesMap", function() { return Strict_mapEntries; }); 182 | __webpack_require__.d(Strict_namespaceObject, "entries_map", function() { return Strict_mapEntries; }); 183 | __webpack_require__.d(Strict_namespaceObject, "mapObject", function() { return Strict_mapObject; }); 184 | __webpack_require__.d(Strict_namespaceObject, "map_object", function() { return Strict_mapObject; }); 185 | __webpack_require__.d(Strict_namespaceObject, "match", function() { return Strict_match; }); 186 | __webpack_require__.d(Strict_namespaceObject, "max", function() { return max; }); 187 | __webpack_require__.d(Strict_namespaceObject, "maxBy", function() { return Strict_maxBy; }); 188 | __webpack_require__.d(Strict_namespaceObject, "max_by", function() { return Strict_maxBy; }); 189 | __webpack_require__.d(Strict_namespaceObject, "min", function() { return min; }); 190 | __webpack_require__.d(Strict_namespaceObject, "minBy", function() { return Strict_minBy; }); 191 | __webpack_require__.d(Strict_namespaceObject, "min_by", function() { return Strict_minBy; }); 192 | __webpack_require__.d(Strict_namespaceObject, "negate", function() { return negate; }); 193 | __webpack_require__.d(Strict_namespaceObject, "noop", function() { return noop; }); 194 | __webpack_require__.d(Strict_namespaceObject, "nop", function() { return Strict_nop; }); 195 | __webpack_require__.d(Strict_namespaceObject, "not", function() { return not; }); 196 | __webpack_require__.d(Strict_namespaceObject, "object", function() { return object_object; }); 197 | __webpack_require__.d(Strict_namespaceObject, "fromEntries", function() { return object_object; }); 198 | __webpack_require__.d(Strict_namespaceObject, "from_entries", function() { return object_object; }); 199 | __webpack_require__.d(Strict_namespaceObject, "omit", function() { return Strict_omit; }); 200 | __webpack_require__.d(Strict_namespaceObject, "partition", function() { return Strict_partition; }); 201 | __webpack_require__.d(Strict_namespaceObject, "pick", function() { return Strict_pick; }); 202 | __webpack_require__.d(Strict_namespaceObject, "pipe", function() { return pipe; }); 203 | __webpack_require__.d(Strict_namespaceObject, "pipe1", function() { return pipe1; }); 204 | __webpack_require__.d(Strict_namespaceObject, "pipeS", function() { return pipeS; }); 205 | __webpack_require__.d(Strict_namespaceObject, "pluck", function() { return Strict_pluck; }); 206 | __webpack_require__.d(Strict_namespaceObject, "prepend", function() { return Strict_prepend; }); 207 | __webpack_require__.d(Strict_namespaceObject, "promiseAllEntries", function() { return promiseAllEntries; }); 208 | __webpack_require__.d(Strict_namespaceObject, "promise_all_entries", function() { return promiseAllEntries; }); 209 | __webpack_require__.d(Strict_namespaceObject, "promiseAllObject", function() { return promiseAllObject; }); 210 | __webpack_require__.d(Strict_namespaceObject, "promise_all_object", function() { return promiseAllObject; }); 211 | __webpack_require__.d(Strict_namespaceObject, "range", function() { return range; }); 212 | __webpack_require__.d(Strict_namespaceObject, "reduce", function() { return reduce; }); 213 | __webpack_require__.d(Strict_namespaceObject, "reduceS", function() { return reduceS; }); 214 | __webpack_require__.d(Strict_namespaceObject, "reject", function() { return Strict_reject; }); 215 | __webpack_require__.d(Strict_namespaceObject, "sel", function() { return Strict_sel; }); 216 | __webpack_require__.d(Strict_namespaceObject, "some", function() { return Strict_some; }); 217 | __webpack_require__.d(Strict_namespaceObject, "sort", function() { return sort; }); 218 | __webpack_require__.d(Strict_namespaceObject, "sortBy", function() { return Strict_sortBy; }); 219 | __webpack_require__.d(Strict_namespaceObject, "sort_by", function() { return Strict_sortBy; }); 220 | __webpack_require__.d(Strict_namespaceObject, "sortByDesc", function() { return Strict_sortByDesc; }); 221 | __webpack_require__.d(Strict_namespaceObject, "sort_by_desc", function() { return Strict_sortByDesc; }); 222 | __webpack_require__.d(Strict_namespaceObject, "sortDesc", function() { return sortDesc_sort; }); 223 | __webpack_require__.d(Strict_namespaceObject, "sort_desc", function() { return sortDesc_sort; }); 224 | __webpack_require__.d(Strict_namespaceObject, "split", function() { return split; }); 225 | __webpack_require__.d(Strict_namespaceObject, "splitEvery", function() { return Strict_splitEvery; }); 226 | __webpack_require__.d(Strict_namespaceObject, "split_every", function() { return Strict_splitEvery; }); 227 | __webpack_require__.d(Strict_namespaceObject, "stop", function() { return stop; }); 228 | __webpack_require__.d(Strict_namespaceObject, "stopIf", function() { return stopIf; }); 229 | __webpack_require__.d(Strict_namespaceObject, "stop_if", function() { return stopIf; }); 230 | __webpack_require__.d(Strict_namespaceObject, "string", function() { return string; }); 231 | __webpack_require__.d(Strict_namespaceObject, "strMap", function() { return Strict_strMap; }); 232 | __webpack_require__.d(Strict_namespaceObject, "str_map", function() { return Strict_strMap; }); 233 | __webpack_require__.d(Strict_namespaceObject, "scat", function() { return Strict_strMap; }); 234 | __webpack_require__.d(Strict_namespaceObject, "tail", function() { return tail; }); 235 | __webpack_require__.d(Strict_namespaceObject, "rest", function() { return tail; }); 236 | __webpack_require__.d(Strict_namespaceObject, "take", function() { return Strict_take; }); 237 | __webpack_require__.d(Strict_namespaceObject, "take1", function() { return Strict_take1; }); 238 | __webpack_require__.d(Strict_namespaceObject, "takeAll", function() { return takeAll; }); 239 | __webpack_require__.d(Strict_namespaceObject, "take_all", function() { return takeAll; }); 240 | __webpack_require__.d(Strict_namespaceObject, "takeUntil", function() { return Strict_takeUntil; }); 241 | __webpack_require__.d(Strict_namespaceObject, "take_until", function() { return Strict_takeUntil; }); 242 | __webpack_require__.d(Strict_namespaceObject, "takeWhile", function() { return Strict_takeWhile; }); 243 | __webpack_require__.d(Strict_namespaceObject, "take_while", function() { return Strict_takeWhile; }); 244 | __webpack_require__.d(Strict_namespaceObject, "tap", function() { return tap; }); 245 | __webpack_require__.d(Strict_namespaceObject, "throttle", function() { return Strict_throttle; }); 246 | __webpack_require__.d(Strict_namespaceObject, "toIter", function() { return toIter; }); 247 | __webpack_require__.d(Strict_namespaceObject, "to_iter", function() { return toIter; }); 248 | __webpack_require__.d(Strict_namespaceObject, "union", function() { return Strict_union; }); 249 | __webpack_require__.d(Strict_namespaceObject, "unionBy", function() { return Strict_unionBy; }); 250 | __webpack_require__.d(Strict_namespaceObject, "union_by", function() { return Strict_unionBy; }); 251 | __webpack_require__.d(Strict_namespaceObject, "unique", function() { return unique; }); 252 | __webpack_require__.d(Strict_namespaceObject, "uniq", function() { return unique; }); 253 | __webpack_require__.d(Strict_namespaceObject, "uniqueBy", function() { return Strict_uniqueBy; }); 254 | __webpack_require__.d(Strict_namespaceObject, "unique_by", function() { return Strict_uniqueBy; }); 255 | __webpack_require__.d(Strict_namespaceObject, "unzip", function() { return unzip; }); 256 | __webpack_require__.d(Strict_namespaceObject, "values", function() { return values; }); 257 | __webpack_require__.d(Strict_namespaceObject, "zip", function() { return Strict_zip; }); 258 | __webpack_require__.d(Strict_namespaceObject, "zipObj", function() { return Strict_zipObj; }); 259 | __webpack_require__.d(Strict_namespaceObject, "zip_obj", function() { return Strict_zipObj; }); 260 | __webpack_require__.d(Strict_namespaceObject, "zipWith", function() { return Strict_zipWith; }); 261 | __webpack_require__.d(Strict_namespaceObject, "zip_with", function() { return Strict_zipWith; }); 262 | var Lazy_namespaceObject = {}; 263 | __webpack_require__.r(Lazy_namespaceObject); 264 | __webpack_require__.d(Lazy_namespaceObject, "append", function() { return appendLazy; }); 265 | __webpack_require__.d(Lazy_namespaceObject, "chunk", function() { return Lazy_chunkLazy; }); 266 | __webpack_require__.d(Lazy_namespaceObject, "compact", function() { return compactLazy; }); 267 | __webpack_require__.d(Lazy_namespaceObject, "concat", function() { return concatLazy; }); 268 | __webpack_require__.d(Lazy_namespaceObject, "constant", function() { return constantLazy; }); 269 | __webpack_require__.d(Lazy_namespaceObject, "deepFlat", function() { return deepFlatLazy; }); 270 | __webpack_require__.d(Lazy_namespaceObject, "deep_flat", function() { return deepFlatLazy; }); 271 | __webpack_require__.d(Lazy_namespaceObject, "deepFlatten", function() { return deepFlatLazy; }); 272 | __webpack_require__.d(Lazy_namespaceObject, "deep_flatten", function() { return deepFlatLazy; }); 273 | __webpack_require__.d(Lazy_namespaceObject, "difference", function() { return Lazy_differenceLazy; }); 274 | __webpack_require__.d(Lazy_namespaceObject, "differenceWith", function() { return Lazy_differenceWithLazy; }); 275 | __webpack_require__.d(Lazy_namespaceObject, "difference_with", function() { return Lazy_differenceWithLazy; }); 276 | __webpack_require__.d(Lazy_namespaceObject, "differenceBy", function() { return Lazy_differenceByLazy; }); 277 | __webpack_require__.d(Lazy_namespaceObject, "difference_by", function() { return Lazy_differenceByLazy; }); 278 | __webpack_require__.d(Lazy_namespaceObject, "drop", function() { return Lazy_dropLazy; }); 279 | __webpack_require__.d(Lazy_namespaceObject, "dropUntil", function() { return Lazy_dropUntilLazy; }); 280 | __webpack_require__.d(Lazy_namespaceObject, "drop_until", function() { return Lazy_dropUntilLazy; }); 281 | __webpack_require__.d(Lazy_namespaceObject, "dropWhile", function() { return Lazy_dropWhileLazy; }); 282 | __webpack_require__.d(Lazy_namespaceObject, "drop_while", function() { return Lazy_dropWhileLazy; }); 283 | __webpack_require__.d(Lazy_namespaceObject, "empty", function() { return emptyLazy; }); 284 | __webpack_require__.d(Lazy_namespaceObject, "entries", function() { return entriesLazy; }); 285 | __webpack_require__.d(Lazy_namespaceObject, "filter", function() { return Lazy_filterLazy; }); 286 | __webpack_require__.d(Lazy_namespaceObject, "flat", function() { return flatLazy; }); 287 | __webpack_require__.d(Lazy_namespaceObject, "flatMap", function() { return Lazy_flatMapLazy; }); 288 | __webpack_require__.d(Lazy_namespaceObject, "flat_map", function() { return Lazy_flatMapLazy; }); 289 | __webpack_require__.d(Lazy_namespaceObject, "zipIndexs", function() { return zipIndexs; }); 290 | __webpack_require__.d(Lazy_namespaceObject, "zip_indexs", function() { return zipIndexs; }); 291 | __webpack_require__.d(Lazy_namespaceObject, "indexValues", function() { return zipIndexs; }); 292 | __webpack_require__.d(Lazy_namespaceObject, "index_values", function() { return zipIndexs; }); 293 | __webpack_require__.d(Lazy_namespaceObject, "intersection", function() { return Lazy_intersectionLazy; }); 294 | __webpack_require__.d(Lazy_namespaceObject, "intersectionWith", function() { return Lazy_intersectionWithLazy; }); 295 | __webpack_require__.d(Lazy_namespaceObject, "intersection_with", function() { return Lazy_intersectionWithLazy; }); 296 | __webpack_require__.d(Lazy_namespaceObject, "intersectionBy", function() { return Lazy_intersectionByLazy; }); 297 | __webpack_require__.d(Lazy_namespaceObject, "intersection_by", function() { return Lazy_intersectionByLazy; }); 298 | __webpack_require__.d(Lazy_namespaceObject, "interval", function() { return intervalLazy; }); 299 | __webpack_require__.d(Lazy_namespaceObject, "keys", function() { return keysLazy; }); 300 | __webpack_require__.d(Lazy_namespaceObject, "mapEntries", function() { return Lazy_mapEntriesLazy; }); 301 | __webpack_require__.d(Lazy_namespaceObject, "map_entries", function() { return Lazy_mapEntriesLazy; }); 302 | __webpack_require__.d(Lazy_namespaceObject, "map", function() { return Lazy_mapLazy; }); 303 | __webpack_require__.d(Lazy_namespaceObject, "prepend", function() { return prependLazy; }); 304 | __webpack_require__.d(Lazy_namespaceObject, "range", function() { return rangeLazy; }); 305 | __webpack_require__.d(Lazy_namespaceObject, "reject", function() { return Lazy_rejectLazy; }); 306 | __webpack_require__.d(Lazy_namespaceObject, "reverse", function() { return reverseLazy; }); 307 | __webpack_require__.d(Lazy_namespaceObject, "splitEvery", function() { return Lazy_splitEveryLazy; }); 308 | __webpack_require__.d(Lazy_namespaceObject, "split_every", function() { return Lazy_splitEveryLazy; }); 309 | __webpack_require__.d(Lazy_namespaceObject, "take", function() { return Lazy_takeLazy; }); 310 | __webpack_require__.d(Lazy_namespaceObject, "takeWhile", function() { return Lazy_takeWhileLazy; }); 311 | __webpack_require__.d(Lazy_namespaceObject, "take_while", function() { return Lazy_takeWhileLazy; }); 312 | __webpack_require__.d(Lazy_namespaceObject, "takeUntil", function() { return Lazy_takeUntilLazy; }); 313 | __webpack_require__.d(Lazy_namespaceObject, "take_until", function() { return Lazy_takeUntilLazy; }); 314 | __webpack_require__.d(Lazy_namespaceObject, "unionBy", function() { return Lazy_unionByLazy; }); 315 | __webpack_require__.d(Lazy_namespaceObject, "union_by", function() { return Lazy_unionByLazy; }); 316 | __webpack_require__.d(Lazy_namespaceObject, "union", function() { return Lazy_unionLazy; }); 317 | __webpack_require__.d(Lazy_namespaceObject, "uniqueBy", function() { return Lazy_uniqueByLazy; }); 318 | __webpack_require__.d(Lazy_namespaceObject, "unique_by", function() { return Lazy_uniqueByLazy; }); 319 | __webpack_require__.d(Lazy_namespaceObject, "unique", function() { return uniqueLazy; }); 320 | __webpack_require__.d(Lazy_namespaceObject, "values", function() { return valuesLazy; }); 321 | __webpack_require__.d(Lazy_namespaceObject, "zip", function() { return Lazy_zipLazy; }); 322 | var Concurrency_namespaceObject = {}; 323 | __webpack_require__.r(Concurrency_namespaceObject); 324 | __webpack_require__.d(Concurrency_namespaceObject, "calls", function() { return callsC; }); 325 | __webpack_require__.d(Concurrency_namespaceObject, "compact", function() { return compactC; }); 326 | __webpack_require__.d(Concurrency_namespaceObject, "drop", function() { return Concurrency_dropC; }); 327 | __webpack_require__.d(Concurrency_namespaceObject, "every", function() { return Concurrency_everyC; }); 328 | __webpack_require__.d(Concurrency_namespaceObject, "filter", function() { return Concurrency_filterC; }); 329 | __webpack_require__.d(Concurrency_namespaceObject, "find", function() { return Concurrency_findC; }); 330 | __webpack_require__.d(Concurrency_namespaceObject, "head", function() { return headC; }); 331 | __webpack_require__.d(Concurrency_namespaceObject, "map", function() { return Concurrency_mapC; }); 332 | __webpack_require__.d(Concurrency_namespaceObject, "mapEntries", function() { return Concurrency_mapEntriesC; }); 333 | __webpack_require__.d(Concurrency_namespaceObject, "object", function() { return objectC; }); 334 | __webpack_require__.d(Concurrency_namespaceObject, "fromEntries", function() { return objectC; }); 335 | __webpack_require__.d(Concurrency_namespaceObject, "from_entries", function() { return objectC; }); 336 | __webpack_require__.d(Concurrency_namespaceObject, "race", function() { return raceC; }); 337 | __webpack_require__.d(Concurrency_namespaceObject, "reduce", function() { return Concurrency_reduceC; }); 338 | __webpack_require__.d(Concurrency_namespaceObject, "some", function() { return Concurrency_someC; }); 339 | __webpack_require__.d(Concurrency_namespaceObject, "tail", function() { return tailC; }); 340 | __webpack_require__.d(Concurrency_namespaceObject, "take1", function() { return take1C; }); 341 | __webpack_require__.d(Concurrency_namespaceObject, "takeAll", function() { return takeAllC; }); 342 | __webpack_require__.d(Concurrency_namespaceObject, "take", function() { return Concurrency_takeC; }); 343 | __webpack_require__.d(Concurrency_namespaceObject, "takeRace", function() { return Concurrency_takeRaceC; }); 344 | 345 | // CONCATENATED MODULE: ./Strict/curry.js 346 | function curry(f) { 347 | return (a, ..._) => _.length < 1 ? (..._) => f(a, ..._) : f(a, ..._); 348 | } 349 | // CONCATENATED MODULE: ./Strict/add.js 350 | 351 | 352 | /* harmony default export */ var add = (curry(function add(a, b) { 353 | return a + b; 354 | })); 355 | 356 | // CONCATENATED MODULE: ./Lazy/emptyLazy.js 357 | const emptyIter = (function *() {} ()); 358 | function emptyLazy() { return emptyIter; }; 359 | 360 | // CONCATENATED MODULE: ./Strict/toIter.js 361 | 362 | 363 | function toIter(iterable) { 364 | return iterable && iterable[Symbol.iterator] ? iterable[Symbol.iterator]() : emptyLazy(); 365 | } 366 | // CONCATENATED MODULE: ./Strict/nop.js 367 | const nop = Symbol.for('nop'); 368 | 369 | /* harmony default export */ var Strict_nop = (nop); 370 | // CONCATENATED MODULE: ./Strict/take.js 371 | 372 | 373 | 374 | 375 | /* harmony default export */ var Strict_take = (curry(function take(l, iter) { 376 | if (l < 1) return []; 377 | let res = []; 378 | iter = toIter(iter); 379 | return function recur() { 380 | let cur; 381 | while (!(cur = iter.next()).done) { 382 | const a = cur.value; 383 | if (a instanceof Promise) { 384 | return a 385 | .then(a => (res.push(a), res).length == l ? res : recur()) 386 | .catch(e => e == Strict_nop ? recur() : Promise.reject(e)); 387 | } 388 | res.push(a); 389 | if (res.length == l) return res; 390 | } 391 | return res; 392 | } (); 393 | })); 394 | // CONCATENATED MODULE: ./Strict/takeAll.js 395 | 396 | 397 | function takeAll(iter) { 398 | return Strict_take(Infinity, iter); 399 | } 400 | // CONCATENATED MODULE: ./Lazy/appendLazy.js 401 | 402 | 403 | /* harmony default export */ var appendLazy = (curry(function *appendLazy(a, iter) { 404 | yield* iter; 405 | yield a; 406 | })); 407 | // CONCATENATED MODULE: ./Strict/append.js 408 | 409 | 410 | 411 | 412 | /* harmony default export */ var Strict_append = (curry(function append(a, iter) { 413 | return takeAll(appendLazy(a, iter)); 414 | })); 415 | // CONCATENATED MODULE: ./Strict/apply.js 416 | 417 | 418 | /* harmony default export */ var apply = (curry(function apply(f, iter) { 419 | return f(...iter); 420 | })); 421 | // CONCATENATED MODULE: ./Strict/isArray.js 422 | const { isArray } = Array; 423 | 424 | /* harmony default export */ var Strict_isArray = (isArray); 425 | // CONCATENATED MODULE: ./Strict/go1.js 426 | /* harmony default export */ var go1 = ((a, f) => a instanceof Promise ? a.then(f) : f(a)); 427 | // CONCATENATED MODULE: ./.internal/go2.js 428 | 429 | 430 | function go2(acc, a, f){ 431 | return a instanceof Promise ? 432 | a.then(a => f(acc, a), e => e == Strict_nop ? acc : Promise.reject(e)) : 433 | f(acc, a); 434 | } 435 | // CONCATENATED MODULE: ./Strict/head.js 436 | 437 | 438 | 439 | function head(iter) { 440 | return go1(Strict_take(1, iter), ([h]) => h); 441 | } 442 | // CONCATENATED MODULE: ./Strict/reduce.js 443 | 444 | 445 | 446 | 447 | 448 | function reduce(f, acc, iter) { 449 | if (arguments.length == 1) return (..._) => reduce(f, ..._); 450 | if (arguments.length == 2) return reduce(f, head(iter = toIter(acc)), iter); 451 | 452 | iter = toIter(iter); 453 | return go1(acc, function recur(acc) { 454 | let cur; 455 | while (!(cur = iter.next()).done) { 456 | acc = go2(acc, cur.value, f); 457 | if (acc instanceof Promise) return acc.then(recur); 458 | } 459 | return acc; 460 | }); 461 | } 462 | // CONCATENATED MODULE: ./Lazy/filterLazy.js 463 | 464 | 465 | 466 | 467 | 468 | /* harmony default export */ var Lazy_filterLazy = (curry(function* filterLazy(f, iter) { 469 | for (const a of toIter(iter)) { 470 | const b = go1(a, f); 471 | if (b instanceof Promise) yield b.then(b => b ? a : Promise.reject(Strict_nop)); 472 | else if (b) yield a; 473 | } 474 | })); 475 | // CONCATENATED MODULE: ./Strict/find.js 476 | 477 | 478 | 479 | 480 | /* harmony default export */ var Strict_find = (curry(function find(f, iter) { 481 | return head(Lazy_filterLazy(f, iter)); 482 | })); 483 | // CONCATENATED MODULE: ./.internal/go1Sync.js 484 | /* harmony default export */ var go1Sync = ((a, f) => f(a)); 485 | // CONCATENATED MODULE: ./Strict/go.js 486 | 487 | 488 | 489 | function go(..._) { 490 | return reduce(go1Sync, _); 491 | } 492 | // CONCATENATED MODULE: ./Lazy/mapLazy.js 493 | 494 | 495 | 496 | 497 | /* harmony default export */ var Lazy_mapLazy = (curry(function* mapLazy(f, iter) { 498 | for (const a of toIter(iter)) yield go1(a, f); 499 | })); 500 | // CONCATENATED MODULE: ./Strict/noop.js 501 | function noop() {}; 502 | // CONCATENATED MODULE: ./Lazy/takeUntilLazy.js 503 | 504 | 505 | 506 | 507 | 508 | 509 | /* harmony default export */ var Lazy_takeUntilLazy = (curry(function* takeUntilLazy(f, iter) { 510 | let prev = null, ok = false; 511 | for (const a of toIter(iter)) { 512 | const _ok = ok || go1(a, f); 513 | if (_ok instanceof Promise) { 514 | _ok.catch(noop); 515 | yield prev = (prev || Promise.resolve()) 516 | .then(_ => _ok) 517 | .then(_ok => ok ? Promise.reject(Strict_nop) : ((ok = _ok), a)); 518 | prev = prev.catch(noop); 519 | } else { 520 | ok = _ok; 521 | yield a; 522 | } 523 | if (ok) break; 524 | } 525 | })); 526 | // CONCATENATED MODULE: ./Strict/not.js 527 | function not(a) { 528 | return !a; 529 | } 530 | // CONCATENATED MODULE: ./Strict/every.js 531 | 532 | 533 | 534 | 535 | 536 | 537 | /* harmony default export */ var Strict_every = (curry(function every(f, iter) { 538 | return go( 539 | Lazy_mapLazy(f, iter), 540 | Lazy_takeUntilLazy(not), 541 | reduce((a, b) => a && b), 542 | (a = false) => a, 543 | Boolean); 544 | })); 545 | // CONCATENATED MODULE: ./Lazy/entriesLazy.js 546 | function* entriesLazy(obj) { 547 | for (const k in obj) yield [k, obj[k]]; 548 | } 549 | // CONCATENATED MODULE: ./Strict/isMatch.js 550 | 551 | 552 | 553 | 554 | 555 | /* harmony default export */ var Strict_isMatch = (curry(function isMatch(a, b) { 556 | return ( 557 | typeof a == 'function' ? !!a(b) 558 | : 559 | Strict_isArray(a) && Strict_isArray(b) ? Strict_every(v => b.includes(v), a) 560 | : 561 | typeof b == 'object' ? Strict_every(([k, v]) => b[k] == v, entriesLazy(a)) 562 | : 563 | a instanceof RegExp ? b.match(a) 564 | : 565 | a == b 566 | ); 567 | })); 568 | // CONCATENATED MODULE: ./Strict/findWhere.js 569 | 570 | 571 | 572 | 573 | /* harmony default export */ var Strict_findWhere = (curry(function findWhere(w, iter) { 574 | return Strict_find(Strict_isMatch(w), iter); 575 | })); 576 | // CONCATENATED MODULE: ./Strict/baseSel.js 577 | 578 | 579 | 580 | 581 | 582 | /* harmony default export */ var baseSel = (sep => curry(function sel(selector, acc) { 583 | return ( 584 | !selector ? 585 | acc 586 | : 587 | Strict_isArray(selector) ? 588 | reduce((acc, selector) => sel(selector, acc), acc, selector) 589 | : 590 | typeof selector == 'object' || typeof selector == 'function' ? 591 | Strict_findWhere(selector, acc) 592 | : 593 | reduce( 594 | (acc, key, s = key[0]) => 595 | !acc ? acc : 596 | s == '#' ? Strict_findWhere({ id: key.substr(1) }, acc) : 597 | s == '[' || s == '{' ? Strict_findWhere(JSON.parse(key), acc) : 598 | acc[key], 599 | acc, 600 | selector.split(sep)) 601 | ); 602 | })); 603 | // CONCATENATED MODULE: ./Strict/call.js 604 | 605 | 606 | /* harmony default export */ var call = (curry(function call(f, ...args) { 607 | return f(...args); 608 | })); 609 | // CONCATENATED MODULE: ./Strict/isIterable.js 610 | function isIterable(a) { 611 | return a != null && !!a[Symbol.iterator]; 612 | } 613 | // CONCATENATED MODULE: ./Lazy/mapEntriesLazy.js 614 | 615 | 616 | 617 | 618 | /* harmony default export */ var Lazy_mapEntriesLazy = (curry(function* mapEntriesLazy(f, iter) { 619 | for (const [k, a] of toIter(iter)) yield go1(go1(a, f), b => [k, b]); 620 | })); 621 | // CONCATENATED MODULE: ./.internal/baseCalls.js 622 | 623 | 624 | 625 | 626 | const baseCalls = (map, object) => function calls(fs, ...args) { 627 | return isIterable(fs) ? 628 | map(f => f(...args), fs) : 629 | object(Lazy_mapEntriesLazy(f => f(...args), entriesLazy(fs))); 630 | }; 631 | 632 | /* harmony default export */ var _internal_baseCalls = (baseCalls); 633 | // CONCATENATED MODULE: ./Strict/map.js 634 | 635 | 636 | 637 | 638 | /* harmony default export */ var Strict_map = (curry(function map(f, iter) { 639 | return takeAll(Lazy_mapLazy(f, iter)); 640 | })); 641 | // CONCATENATED MODULE: ./Strict/object.js 642 | 643 | 644 | function object_object(iter) { 645 | return reduce((obj, [k, v]) => (obj[k] = v, obj), {}, iter); 646 | } 647 | // CONCATENATED MODULE: ./Strict/calls.js 648 | 649 | 650 | 651 | 652 | /* harmony default export */ var Strict_calls = (_internal_baseCalls(Strict_map, object_object)); 653 | // CONCATENATED MODULE: ./Lazy/rangeLazy.js 654 | function* rangeLazy(start = 0, stop = start, step = 1) { 655 | if (arguments.length === 1) start = 0; 656 | if (arguments.length < 3 && start > stop) step *= -1; 657 | 658 | if (start < stop) { 659 | while (start < stop) { 660 | yield start; 661 | start += step; 662 | } 663 | } else { 664 | while (start > stop) { 665 | yield start; 666 | start += step; 667 | } 668 | } 669 | } 670 | // CONCATENATED MODULE: ./Lazy/chunkLazy.js 671 | 672 | 673 | 674 | 675 | 676 | 677 | 678 | 679 | /* harmony default export */ var Lazy_chunkLazy = (curry(function chunkLazy(n, iter) { 680 | iter = toIter(iter); 681 | return go( 682 | rangeLazy(Infinity), 683 | Lazy_mapLazy(_ => Strict_take(n, iter)), 684 | Lazy_takeUntilLazy(c => c.length < n)) 685 | })); 686 | // CONCATENATED MODULE: ./Strict/chunk.js 687 | 688 | 689 | 690 | 691 | /* harmony default export */ var Strict_chunk = (curry(function chunk(n, iter) { 692 | return takeAll(Lazy_chunkLazy(n, iter)); 693 | })); 694 | // CONCATENATED MODULE: ./Strict/filter.js 695 | 696 | 697 | 698 | 699 | /* harmony default export */ var Strict_filter = (curry(function filter(f, iter) { 700 | return takeAll(Lazy_filterLazy(f, iter)); 701 | })); 702 | // CONCATENATED MODULE: ./Strict/compact.js 703 | 704 | 705 | /* harmony default export */ var compact = (Strict_filter(a => a)); 706 | // CONCATENATED MODULE: ./Strict/constant.js 707 | function constant(a) { 708 | return _ => a; 709 | } 710 | // CONCATENATED MODULE: ./Strict/countBy.js 711 | 712 | 713 | 714 | function incSel(parent, k) { 715 | parent[k] ? parent[k]++ : parent[k] = 1; 716 | return parent; 717 | } 718 | 719 | /* harmony default export */ var Strict_countBy = (curry(function countBy(f, iter) { 720 | return reduce((counts, a) => incSel(counts, f(a)), {}, iter); 721 | })); 722 | // CONCATENATED MODULE: ./Strict/delay.js 723 | 724 | 725 | /* harmony default export */ var delay = (curry(async function delay(time, a) { 726 | await new Promise(resolve => setTimeout(resolve, time)); 727 | return a; 728 | })); 729 | // CONCATENATED MODULE: ./Strict/debounce.js 730 | 731 | 732 | 733 | /* harmony default export */ var Strict_debounce = (curry(function debounce(f, time) { 734 | let i = 0; 735 | return function _debounce(...args) { 736 | return delay(time, ++i).then(id => id === i && f(...args)); 737 | }; 738 | })); 739 | // CONCATENATED MODULE: ./Strict/last.js 740 | function last(arr) { 741 | return arr[arr.length - 1]; 742 | } 743 | // CONCATENATED MODULE: ./Lazy/flatLazy.js 744 | 745 | 746 | 747 | 748 | 749 | function flatLazy(iter, depth = 1) { 750 | let concurCheck = null; 751 | const iterStack = [toIter(iter)]; 752 | return { 753 | next: function recur() { 754 | const iter = last(iterStack); 755 | if (!iter) return { done: true }; 756 | const cur = iter.next(); 757 | if (cur.done) { 758 | iterStack.pop(); 759 | return recur(); 760 | } else if (iterStack.length <= depth && isIterable(cur.value) && typeof cur.value != 'string') { 761 | iterStack.push(cur.value[Symbol.iterator]()); 762 | return recur(); 763 | } else if (cur.value instanceof Promise) { 764 | if (concurCheck && !concurCheck.done) { 765 | iterStack.length = 0; 766 | return { value: Promise.reject(new Error("'L.flat' can not be used with 'C' function.")), done: false }; 767 | } 768 | concurCheck = concurCheck || {}; 769 | return { 770 | value: cur.value.then(value => { 771 | if (!concurCheck.hasOwnProperty('done')) concurCheck.done = true; 772 | if (iterStack.length > depth || !isIterable(value) || typeof value == 'string') return value; 773 | const iter = value[Symbol.iterator](), cur = iter.next(); 774 | return cur.done ? Promise.reject(Strict_nop) : (iterStack.push(iter), cur.value); 775 | }).catch(e => { 776 | if (!concurCheck.hasOwnProperty('done')) concurCheck.done = true; 777 | return Promise.reject(e); 778 | }), 779 | done: false 780 | }; 781 | } else { 782 | return cur; 783 | } 784 | }, 785 | [Symbol.iterator]() { return this; } 786 | }; 787 | } 788 | // CONCATENATED MODULE: ./Lazy/deepFlatLazy.js 789 | 790 | 791 | function deepFlatLazy(iter) { 792 | return flatLazy(iter, Infinity); 793 | } 794 | // CONCATENATED MODULE: ./Strict/deepFlat.js 795 | 796 | 797 | 798 | function deepFlat(iter) { 799 | return takeAll(deepFlatLazy(iter)); 800 | } 801 | // CONCATENATED MODULE: ./.internal/baseExtend.js 802 | 803 | 804 | 805 | 806 | function baseExtend(set, obj, objs) { 807 | const type = typeof obj; 808 | obj && 809 | (type == 'object' || type == 'function') && 810 | reduce(reduce(set), obj, Lazy_mapLazy(entriesLazy, objs)); 811 | return obj; 812 | } 813 | // CONCATENATED MODULE: ./Strict/has.js 814 | 815 | 816 | /* harmony default export */ var has = (curry(function has(k, obj) { 817 | return !!(obj && obj.hasOwnProperty(k)); 818 | })); 819 | // CONCATENATED MODULE: ./Strict/defaults.js 820 | 821 | 822 | 823 | const setter = (obj, [k, v]) => { 824 | return (has(k, obj) || (obj[k] = v, obj), obj); 825 | }; 826 | 827 | function defaults(obj, ...objs) { 828 | return baseExtend(setter, obj, objs); 829 | } 830 | 831 | /* harmony default export */ var Strict_defaults = (defaults); 832 | // CONCATENATED MODULE: ./Strict/defaultTo.js 833 | 834 | 835 | /* harmony default export */ var defaultTo = (curry(function defaultTo(a, b) { 836 | return (b == null || Number.isNaN(b)) ? a : b; 837 | })); 838 | // CONCATENATED MODULE: ./Strict/identity.js 839 | /* harmony default export */ var identity = (a => a); 840 | // CONCATENATED MODULE: ./Lazy/rejectLazy.js 841 | 842 | 843 | 844 | 845 | 846 | /* harmony default export */ var Lazy_rejectLazy = (curry(function rejectLazy(f, iter) { 847 | return Lazy_filterLazy(a => go1(f(a), not), iter); 848 | })); 849 | // CONCATENATED MODULE: ./Lazy/differenceByLazy.js 850 | 851 | 852 | 853 | 854 | 855 | 856 | /* harmony default export */ var Lazy_differenceByLazy = (curry(function differenceByLazy(f, iter2, iter) { 857 | let set; 858 | return Lazy_rejectLazy(a => go1( 859 | set || go1(Strict_map(f, iter2), b => set = new Set(b)), 860 | set => go(a, f, b => set.has(b)) 861 | ), iter); 862 | })); 863 | // CONCATENATED MODULE: ./Lazy/differenceLazy.js 864 | 865 | 866 | 867 | 868 | /* harmony default export */ var Lazy_differenceLazy = (curry(function differenceLazy(b, a) { 869 | return Lazy_differenceByLazy(identity, b, a); 870 | })); 871 | 872 | // CONCATENATED MODULE: ./Strict/difference.js 873 | 874 | 875 | 876 | 877 | 878 | /* harmony default export */ var Strict_difference = (curry(function difference(b, a) { 879 | return go( 880 | Lazy_differenceLazy(b, a), 881 | takeAll 882 | ); 883 | })); 884 | // CONCATENATED MODULE: ./Strict/differenceBy.js 885 | 886 | 887 | 888 | 889 | 890 | /* harmony default export */ var Strict_differenceBy = (curry(function differenceBy(f, b, a) { 891 | return go( 892 | Lazy_differenceByLazy(f, b, a), 893 | takeAll 894 | ) 895 | })); 896 | // CONCATENATED MODULE: ./Lazy/differenceWithLazy.js 897 | 898 | 899 | 900 | 901 | 902 | 903 | /* harmony default export */ var Lazy_differenceWithLazy = (curry(function differenceWithLazy(f, iter1, iter2) { 904 | return Lazy_rejectLazy( 905 | a => go1(Strict_take(1, Lazy_filterLazy(b => f(a, b), iter2)), b => b.length), 906 | iter1); 907 | })); 908 | // CONCATENATED MODULE: ./Strict/differenceWith.js 909 | 910 | 911 | 912 | 913 | /* harmony default export */ var Strict_differenceWith = (curry(function differenceWith(f, iter1, iter2) { 914 | return takeAll(Lazy_differenceWithLazy(f, iter1, iter2)); 915 | })); 916 | // CONCATENATED MODULE: ./Lazy/dropLazy.js 917 | 918 | 919 | 920 | 921 | 922 | /* harmony default export */ var Lazy_dropLazy = (curry(function* dropLazy(l, iter) { 923 | if (l < 1) yield* iter; 924 | let prev = null, i = 0; 925 | iter = toIter(iter); 926 | for(const a of iter) { 927 | if (a instanceof Promise) { 928 | a.catch(noop); 929 | yield prev = (prev || Promise.resolve()) 930 | .then(_ => a) 931 | .then(b => ++i > l ? b : Promise.reject(Strict_nop)); 932 | prev = prev.catch(noop); 933 | } else if (++i == l) return yield* iter; 934 | } 935 | })); 936 | // CONCATENATED MODULE: ./Strict/drop.js 937 | 938 | 939 | 940 | 941 | /* harmony default export */ var Strict_drop = (curry(function drop(l, iter) { 942 | return takeAll(Lazy_dropLazy(l, iter)); 943 | })); 944 | // CONCATENATED MODULE: ./Strict/dropRight.js 945 | 946 | 947 | 948 | 949 | 950 | /* harmony default export */ var dropRight = (curry(function drop(l, iter) { 951 | return go1(takeAll(iter), arr => Strict_take(arr.length - l, arr)); 952 | })); 953 | // CONCATENATED MODULE: ./Lazy/dropUntilLazy.js 954 | 955 | 956 | 957 | 958 | 959 | 960 | /* harmony default export */ var Lazy_dropUntilLazy = (curry(function* dropUntilLazy(f, iter) { 961 | let prev = null, ok = false; 962 | iter = toIter(iter); 963 | for(const a of iter) { 964 | const cond = ok || go1(a, f); 965 | if (cond instanceof Promise) { 966 | cond.catch(noop); 967 | yield prev = (prev || Promise.resolve()) 968 | .then(_ => cond) 969 | .then(c => ok ? a : (ok = c, Promise.reject(Strict_nop))); 970 | prev = prev.catch(noop); 971 | } else ok = cond; 972 | if (ok) return yield* iter; 973 | } 974 | })); 975 | // CONCATENATED MODULE: ./Strict/dropUntil.js 976 | 977 | 978 | 979 | 980 | /* harmony default export */ var dropUntil = (curry(function dropWhile(f, iter) { 981 | return takeAll(Lazy_dropUntilLazy(f, iter)); 982 | })); 983 | // CONCATENATED MODULE: ./Lazy/dropWhileLazy.js 984 | 985 | 986 | 987 | 988 | 989 | 990 | 991 | /* harmony default export */ var Lazy_dropWhileLazy = (curry(function* dropWhileLazy(f, iter) { 992 | let prev = null, ok = false; 993 | iter = toIter(iter); 994 | for(const a of iter) { 995 | const cond = ok || go1(a, f); 996 | if (cond instanceof Promise) { 997 | cond.catch(noop); 998 | yield prev = (prev || Promise.resolve()) 999 | .then(_ => cond) 1000 | .then(c => (ok = !c) ? a : Promise.reject(Strict_nop)); 1001 | prev = prev.catch(noop); 1002 | } else if (ok || (ok = !cond)) return yield* flatLazy([a, iter]); 1003 | } 1004 | })); 1005 | // CONCATENATED MODULE: ./Strict/dropWhile.js 1006 | 1007 | 1008 | 1009 | 1010 | 1011 | /* harmony default export */ var Strict_dropWhile = (curry(function dropWhile(f, iter) { 1012 | return go1(iter, _iter => takeAll(Lazy_dropWhileLazy(f, _iter))); 1013 | })); 1014 | // CONCATENATED MODULE: ./Strict/each.js 1015 | 1016 | 1017 | 1018 | 1019 | /* harmony default export */ var Strict_each = (curry(function each(f, iter) { 1020 | return Strict_map(a => go1(f(a), _ => a), iter); 1021 | })); 1022 | // CONCATENATED MODULE: ./Strict/entries.js 1023 | 1024 | 1025 | 1026 | function entries_entries(a) { 1027 | return takeAll(entriesLazy(a)); 1028 | } 1029 | // CONCATENATED MODULE: ./Strict/extend.js 1030 | 1031 | 1032 | const extend_setter = (obj, [k, v]) => (obj[k] = v, obj); 1033 | 1034 | function extend(obj, ...objs) { 1035 | return baseExtend(extend_setter, obj, objs); 1036 | } 1037 | // CONCATENATED MODULE: ./Strict/flat.js 1038 | 1039 | 1040 | 1041 | function flat(iter, depth = 1) { 1042 | return takeAll(flatLazy(iter, depth)); 1043 | } 1044 | // CONCATENATED MODULE: ./Strict/flatMap.js 1045 | 1046 | 1047 | 1048 | 1049 | /* harmony default export */ var Strict_flatMap = (curry(function flatMap(f, iter) { 1050 | return flat(Lazy_mapLazy(f, iter)); 1051 | })); 1052 | // CONCATENATED MODULE: ./Strict/isStop.js 1053 | const SymbolStop = Symbol.for('stop'); 1054 | 1055 | function isStop(a) { 1056 | return !!(a && a[SymbolStop]); 1057 | } 1058 | // CONCATENATED MODULE: ./Strict/reduceS.js 1059 | 1060 | 1061 | 1062 | 1063 | 1064 | 1065 | function reduceS(f, acc, iter) { 1066 | if (arguments.length == 1) return (..._) => reduceS(f, ..._); 1067 | if (arguments.length == 2) return reduceS(f, head(iter = toIter(acc)), iter); 1068 | 1069 | iter = toIter(iter); 1070 | return go1(acc, function recur(acc) { 1071 | let cur; 1072 | while (!isStop(acc) && !(cur = iter.next()).done) { 1073 | acc = go2(acc, cur.value, f); 1074 | if (acc instanceof Promise) return acc.then(recur); 1075 | } 1076 | return isStop(acc) ? acc.value : acc; 1077 | }); 1078 | } 1079 | // CONCATENATED MODULE: ./Strict/goS.js 1080 | 1081 | 1082 | 1083 | function goS(..._) { 1084 | return reduceS(go1Sync, _); 1085 | } 1086 | // CONCATENATED MODULE: ./Strict/groupBy.js 1087 | 1088 | 1089 | 1090 | 1091 | /* harmony default export */ var Strict_groupBy = (curry(function groupBy(f, iter) { 1092 | return reduce( 1093 | (group, a) => go1( 1094 | f(a), 1095 | k => ((group[k] || (group[k] = [])).push(a), group)), 1096 | {}, 1097 | iter); 1098 | })); 1099 | // CONCATENATED MODULE: ./Strict/tap.js 1100 | 1101 | 1102 | 1103 | 1104 | function tap(f, ...fs) { 1105 | return (a, ...as) => go1(reduce(go1Sync, f(a, ...as), fs), _ => a); 1106 | } 1107 | // CONCATENATED MODULE: ./Strict/log.js 1108 | const { log } = console; 1109 | 1110 | /* harmony default export */ var Strict_log = (log); 1111 | // CONCATENATED MODULE: ./Strict/hi.js 1112 | 1113 | 1114 | 1115 | const hi_f = tap(Strict_log); 1116 | 1117 | function hi(..._) { return hi_f(..._); } 1118 | // CONCATENATED MODULE: ./Strict/html.js 1119 | 1120 | 1121 | 1122 | 1123 | function html(strs, ...datas) { 1124 | datas = Lazy_mapLazy(d => d === undefined ? '' : d, datas); 1125 | return go1( 1126 | reduce((res, str) => go1(datas.next().value, data => `${res}${data}${str}`), strs), 1127 | a => a.replace(/\s*(\>|\<)\s*/g, '$1').trim()); 1128 | } 1129 | // CONCATENATED MODULE: ./Strict/indexBy.js 1130 | 1131 | 1132 | 1133 | /* harmony default export */ var Strict_indexBy = (curry(function indexBy(f, iter) { 1134 | return reduce((obj, a) => (obj[f(a)] = a, obj), {}, iter); 1135 | })); 1136 | // CONCATENATED MODULE: ./Strict/initial.js 1137 | 1138 | 1139 | function initial(a) { 1140 | return dropRight(1, a); 1141 | } 1142 | // CONCATENATED MODULE: ./Strict/pipe.js 1143 | 1144 | 1145 | 1146 | function pipe(f, ...fs) { 1147 | return (...as) => reduce(go1Sync, f(...as), fs); 1148 | } 1149 | // CONCATENATED MODULE: ./Lazy/uniqueByLazy.js 1150 | 1151 | 1152 | 1153 | 1154 | 1155 | const uniqueByLazy_uniqueByLazy = curry(function uniqueByLazy(f, iter) { 1156 | const s = new Set(); 1157 | return go1( 1158 | iter, 1159 | Lazy_filterLazy(pipe( 1160 | f, 1161 | b => s.has(b) ? false : s.add(b)))); 1162 | }); 1163 | 1164 | /* harmony default export */ var Lazy_uniqueByLazy = (uniqueByLazy_uniqueByLazy); 1165 | // CONCATENATED MODULE: ./Lazy/uniqueLazy.js 1166 | 1167 | 1168 | 1169 | function uniqueLazy(obj) { 1170 | return Lazy_uniqueByLazy(identity, obj); 1171 | }; 1172 | // CONCATENATED MODULE: ./Lazy/intersectionByLazy.js 1173 | 1174 | 1175 | 1176 | 1177 | 1178 | 1179 | 1180 | /* harmony default export */ var Lazy_intersectionByLazy = (curry(function intersectionByLazy(f, iter2, iter) { 1181 | let set = null; 1182 | return uniqueLazy( 1183 | Lazy_filterLazy( 1184 | a => go1( 1185 | set || go1(Lazy_mapLazy(f, iter2), l => set = new Set(l)), 1186 | set => go(a, f, b => set.has(b)) 1187 | ), 1188 | iter)); 1189 | })); 1190 | // CONCATENATED MODULE: ./Lazy/intersectionLazy.js 1191 | 1192 | 1193 | 1194 | 1195 | /* harmony default export */ var Lazy_intersectionLazy = (curry(function intersectionLazy(a, b) { 1196 | return Lazy_intersectionByLazy(identity, a, b); 1197 | })); 1198 | // CONCATENATED MODULE: ./Strict/intersection.js 1199 | 1200 | 1201 | 1202 | 1203 | 1204 | /* harmony default export */ var Strict_intersection = (curry(function intersection(a, b) { 1205 | return go( 1206 | b, 1207 | Lazy_intersectionLazy(a), 1208 | takeAll 1209 | ) 1210 | })); 1211 | // CONCATENATED MODULE: ./Strict/intersectionBy.js 1212 | 1213 | 1214 | 1215 | 1216 | 1217 | /* harmony default export */ var Strict_intersectionBy = (curry(function intersectionBy(f, b, a) { 1218 | return go(Lazy_intersectionByLazy(f, b, a), takeAll); 1219 | })); 1220 | // CONCATENATED MODULE: ./Lazy/intersectionWithLazy.js 1221 | 1222 | 1223 | 1224 | 1225 | 1226 | 1227 | /* harmony default export */ var Lazy_intersectionWithLazy = (curry(function intersectionWithLazy(f, iter1, iter2) { 1228 | return Lazy_filterLazy( 1229 | a => go1(Strict_take(1, Lazy_filterLazy(b => f(a, b), iter2)), b => b.length), 1230 | iter1); 1231 | })); 1232 | // CONCATENATED MODULE: ./Strict/intersectionWith.js 1233 | 1234 | 1235 | 1236 | 1237 | /* harmony default export */ var Strict_intersectionWith = (curry(function intersectionWith(f, iter1, iter2) { 1238 | return takeAll(Lazy_intersectionWithLazy(f, iter1, iter2)); 1239 | })); 1240 | // CONCATENATED MODULE: ./Strict/isFunction.js 1241 | function isFunction(a) { 1242 | return typeof a == 'function'; 1243 | } 1244 | // CONCATENATED MODULE: ./Strict/isString.js 1245 | function isString(a) { 1246 | return typeof a == 'string'; 1247 | } 1248 | // CONCATENATED MODULE: ./Strict/isUndefined.js 1249 | /* harmony default export */ var isUndefined = (a => a === undefined); 1250 | // CONCATENATED MODULE: ./Strict/join.js 1251 | 1252 | 1253 | 1254 | /* harmony default export */ var Strict_join = (curry(function join(sep, iter) { 1255 | return reduce((acc, a) => `${acc}${sep}${a}`, iter); 1256 | })); 1257 | // CONCATENATED MODULE: ./Lazy/keysLazy.js 1258 | function* keysLazy(obj) { 1259 | for (const k in obj) yield k; 1260 | }; 1261 | // CONCATENATED MODULE: ./Strict/keys.js 1262 | 1263 | 1264 | 1265 | function keys(a) { 1266 | return takeAll(keysLazy(a)); 1267 | } 1268 | // CONCATENATED MODULE: ./Strict/mapEntries.js 1269 | 1270 | 1271 | 1272 | 1273 | /* harmony default export */ var Strict_mapEntries = (curry(function mapEntries(f, iter) { 1274 | return takeAll(Lazy_mapEntriesLazy(f, iter)); 1275 | })); 1276 | // CONCATENATED MODULE: ./Strict/mapObject.js 1277 | 1278 | 1279 | 1280 | 1281 | 1282 | /* harmony default export */ var Strict_mapObject = (curry(function mapObject(f, obj) { 1283 | return object_object(Lazy_mapEntriesLazy(f, entriesLazy(obj))); 1284 | })); 1285 | // CONCATENATED MODULE: ./Lazy/valuesLazy.js 1286 | function* valuesLazy(obj) { 1287 | for (const k in obj) yield obj[k]; 1288 | } 1289 | // CONCATENATED MODULE: ./Strict/values.js 1290 | 1291 | 1292 | 1293 | function values(a) { 1294 | return takeAll(valuesLazy(a)); 1295 | } 1296 | // CONCATENATED MODULE: ./Strict/match.js 1297 | 1298 | 1299 | 1300 | 1301 | 1302 | 1303 | function baseMatch(targets) { 1304 | var cbs = []; 1305 | 1306 | function evl() { 1307 | return go( 1308 | targets, 1309 | values, 1310 | targets => 1311 | go(cbs, 1312 | Strict_find(pb => { return pb._case(...targets); }), 1313 | pb => pb._body(...targets))); 1314 | } 1315 | 1316 | function _case(f) { 1317 | cbs.push({ _case: typeof f == 'function' ? pipe(...arguments) : Strict_isMatch(f) }); 1318 | return _body; 1319 | } 1320 | _case.case = _case; 1321 | 1322 | function _body() { 1323 | cbs[cbs.length-1]._body = pipe(...arguments); 1324 | return _case; 1325 | } 1326 | 1327 | _case.else = function() { 1328 | _case(_=> true) (...arguments); 1329 | return targets ? evl() : (...targets2) => ((targets = targets2), evl()); 1330 | }; 1331 | 1332 | return _case; 1333 | } 1334 | 1335 | function match(..._) { 1336 | return baseMatch(_); 1337 | } 1338 | 1339 | match.case = (..._) => baseMatch(null).case(..._); 1340 | 1341 | /* harmony default export */ var Strict_match = (match); 1342 | // CONCATENATED MODULE: ./Strict/maxBy.js 1343 | 1344 | 1345 | 1346 | /* harmony default export */ var Strict_maxBy = (curry(function maxBy(f, iter) { 1347 | return reduce((a, b) => f(a) >= f(b) ? a : b, iter); 1348 | })); 1349 | // CONCATENATED MODULE: ./Strict/max.js 1350 | 1351 | 1352 | function max(iter) { 1353 | return Strict_maxBy(a => a, iter); 1354 | } 1355 | // CONCATENATED MODULE: ./Strict/minBy.js 1356 | 1357 | 1358 | 1359 | /* harmony default export */ var Strict_minBy = (curry(function minBy(f, iter) { 1360 | return reduce((a, b) => f(a) <= f(b) ? a : b, iter); 1361 | })); 1362 | // CONCATENATED MODULE: ./Strict/min.js 1363 | 1364 | 1365 | function min(iter) { 1366 | return Strict_minBy(a => a, iter); 1367 | } 1368 | // CONCATENATED MODULE: ./Strict/negate.js 1369 | 1370 | 1371 | 1372 | function negate(f) { 1373 | return (..._) => go1(f(..._), not); 1374 | } 1375 | // CONCATENATED MODULE: ./Strict/omit.js 1376 | 1377 | 1378 | 1379 | 1380 | 1381 | /* harmony default export */ var Strict_omit = (curry(function omit(ks, obj) { 1382 | return object_object( 1383 | Lazy_rejectLazy(([k]) => ks.includes(k), 1384 | entriesLazy(obj))); 1385 | })); 1386 | // CONCATENATED MODULE: ./Strict/pipe1.js 1387 | 1388 | 1389 | /* harmony default export */ var pipe1 = ((g, f) => a => go1(g(a), f)); 1390 | 1391 | // CONCATENATED MODULE: ./Strict/partition.js 1392 | 1393 | 1394 | 1395 | 1396 | 1397 | /* harmony default export */ var Strict_partition = (curry(function partition(f, iter) { 1398 | return go1( 1399 | Strict_groupBy(pipe1(f, Boolean), iter), 1400 | group => [group['true'], group['false']]); 1401 | })); 1402 | // CONCATENATED MODULE: ./Strict/pick.js 1403 | 1404 | 1405 | 1406 | 1407 | 1408 | /* harmony default export */ var Strict_pick = (curry(function pick(ks, obj) { 1409 | return object_object( 1410 | Lazy_rejectLazy(([_, v]) => v === undefined, 1411 | Lazy_mapLazy(k => [k, obj[k]], ks))); 1412 | })); 1413 | // CONCATENATED MODULE: ./Strict/pipeS.js 1414 | 1415 | 1416 | 1417 | function pipeS(f, ...fs) { 1418 | return (...as) => reduceS(go1Sync, f(...as), fs); 1419 | } 1420 | // CONCATENATED MODULE: ./Strict/pluck.js 1421 | 1422 | 1423 | 1424 | /* harmony default export */ var Strict_pluck = (curry(function pluck(k, iter) { 1425 | return Strict_map(a => a[k], iter); 1426 | })); 1427 | // CONCATENATED MODULE: ./Lazy/prependLazy.js 1428 | 1429 | 1430 | /* harmony default export */ var prependLazy = (curry(function *prependLazy(a, iter) { 1431 | yield a; 1432 | yield* iter; 1433 | })); 1434 | // CONCATENATED MODULE: ./Strict/prepend.js 1435 | 1436 | 1437 | 1438 | 1439 | /* harmony default export */ var Strict_prepend = (curry(function prepend(a, iter) { 1440 | return takeAll(prependLazy(a, iter)); 1441 | })); 1442 | // CONCATENATED MODULE: ./Strict/promiseAllEntries.js 1443 | 1444 | 1445 | 1446 | function promiseAllEntries(entries) { 1447 | return Strict_mapEntries(identity, entries); 1448 | } 1449 | // CONCATENATED MODULE: ./Strict/promiseAllObject.js 1450 | 1451 | 1452 | 1453 | function promiseAllObject(obj) { 1454 | return Strict_mapObject(identity, obj); 1455 | } 1456 | // CONCATENATED MODULE: ./Strict/range.js 1457 | 1458 | 1459 | 1460 | function range(..._) { 1461 | return takeAll(rangeLazy(..._)); 1462 | } 1463 | // CONCATENATED MODULE: ./Strict/reject.js 1464 | 1465 | 1466 | 1467 | 1468 | 1469 | /* harmony default export */ var Strict_reject = (curry(function reject(f, iter) { 1470 | return Strict_filter(a => go1(f(a), not), iter); 1471 | })); 1472 | // CONCATENATED MODULE: ./Strict/sel.js 1473 | 1474 | 1475 | /* harmony default export */ var Strict_sel = (baseSel('.')); 1476 | // CONCATENATED MODULE: ./Strict/some.js 1477 | 1478 | 1479 | 1480 | 1481 | 1482 | 1483 | /* harmony default export */ var Strict_some = (curry(function some(f, iter) { 1484 | return go( 1485 | Lazy_mapLazy(f, iter), 1486 | Lazy_takeUntilLazy(identity), 1487 | reduce((a, b) => a || b), 1488 | (a = false) => a, 1489 | Boolean); 1490 | })); 1491 | // CONCATENATED MODULE: ./.internal/baseSortBy.js 1492 | 1493 | 1494 | 1495 | const arrComparator = (arr) => (a, b) => { 1496 | let i = -1; 1497 | while (++i < arr.length) { 1498 | const ai = a[arr[i]], bi = b[arr[i]]; 1499 | if (ai === bi) continue; 1500 | return ai < bi ? -1 : 1; 1501 | } 1502 | return 0; 1503 | }; 1504 | 1505 | function baseSortBy(left, right, f, arr) { 1506 | return Strict_isArray(f) ? baseSortBy(left, right, arrComparator(f), arr) : 1507 | typeof f == 'string' ? baseSortBy(left, right, a => a[f], arr) : 1508 | f.length == 2 ? [...arr].sort(right == -1 ? pipe(f, n => n * -1) : f) : 1509 | [...arr].sort((a, b, fa = f(a), fb = f(b)) => fa == fb ? 0 : fa < fb ? left : right) 1510 | } 1511 | // CONCATENATED MODULE: ./Strict/sortBy.js 1512 | 1513 | 1514 | 1515 | /* harmony default export */ var Strict_sortBy = (curry(function sortBy(f, arr) { 1516 | return baseSortBy(-1, 1, f, arr); 1517 | })); 1518 | // CONCATENATED MODULE: ./Strict/sort.js 1519 | 1520 | 1521 | function sort(arr) { 1522 | return Strict_sortBy(a => a, arr); 1523 | } 1524 | // CONCATENATED MODULE: ./Strict/sortByDesc.js 1525 | 1526 | 1527 | 1528 | /* harmony default export */ var Strict_sortByDesc = (curry(function sortByDesc(f, arr) { 1529 | return baseSortBy(1, -1, f, arr); 1530 | })); 1531 | // CONCATENATED MODULE: ./Strict/sortDesc.js 1532 | 1533 | 1534 | function sortDesc_sort(arr) { 1535 | return Strict_sortByDesc(a => a, arr); 1536 | } 1537 | // CONCATENATED MODULE: ./Strict/split.js 1538 | 1539 | 1540 | /* harmony default export */ var split = (curry(function split(sep, str) { 1541 | return (str || "").split(sep); 1542 | })); 1543 | // CONCATENATED MODULE: ./Lazy/splitEveryLazy.js 1544 | 1545 | 1546 | 1547 | 1548 | 1549 | 1550 | /* harmony default export */ var Lazy_splitEveryLazy = (curry(function splitEveryLazy(n, str) { 1551 | if (!str) return emptyLazy(); 1552 | return Lazy_mapLazy(i => str.substr(i * n, n), rangeLazy(Math.ceil(str.length / n))); 1553 | })); 1554 | // CONCATENATED MODULE: ./Strict/splitEvery.js 1555 | 1556 | 1557 | 1558 | 1559 | /* harmony default export */ var Strict_splitEvery = (curry(function splitEvery(n, str) { 1560 | return takeAll(Lazy_splitEveryLazy(n, str)); 1561 | })); 1562 | // CONCATENATED MODULE: ./Strict/stop.js 1563 | const stop_SymbolStop = Symbol.for('stop'); 1564 | 1565 | function stop(value) { 1566 | return { [stop_SymbolStop]: true, value }; 1567 | } 1568 | // CONCATENATED MODULE: ./Strict/stopIf.js 1569 | 1570 | 1571 | 1572 | function stopIf(f, stopVal) { 1573 | return Strict_match.case(f)(arguments.length == 2 ? _ => stop(stopVal) : stop).else(a => a); 1574 | } 1575 | // CONCATENATED MODULE: ./Strict/string.js 1576 | 1577 | 1578 | function string(iter) { 1579 | return reduce((a, b) => `${a}${b}`, iter); 1580 | } 1581 | // CONCATENATED MODULE: ./Strict/strMap.js 1582 | 1583 | 1584 | 1585 | 1586 | /* harmony default export */ var Strict_strMap = (curry(function strMap(f, iter) { 1587 | return string(Lazy_mapLazy(f, iter)); 1588 | })); 1589 | // CONCATENATED MODULE: ./Strict/tail.js 1590 | 1591 | 1592 | function tail(iter) { 1593 | return Strict_drop(1, iter); 1594 | } 1595 | // CONCATENATED MODULE: ./Strict/take1.js 1596 | 1597 | 1598 | const take1 = Strict_take(1); 1599 | 1600 | /* harmony default export */ var Strict_take1 = (take1); 1601 | // CONCATENATED MODULE: ./Strict/takeUntil.js 1602 | 1603 | 1604 | 1605 | 1606 | 1607 | /* harmony default export */ var Strict_takeUntil = (curry(function takeUntil(f, iter) { 1608 | let res = []; 1609 | iter = toIter(iter); 1610 | return function recur() { 1611 | let cur; 1612 | while (!(cur = iter.next()).done) { 1613 | const a = cur.value; 1614 | const b = go1(a, a => (res.push(a), f(a, res))); 1615 | if (b instanceof Promise) 1616 | return b.then(b => b ? res : recur()).catch(e => e == Strict_nop ? recur() : Promise.reject(e)); 1617 | if (b) break; 1618 | } 1619 | return res; 1620 | } (); 1621 | })); 1622 | // CONCATENATED MODULE: ./Strict/takeWhile.js 1623 | 1624 | 1625 | 1626 | 1627 | 1628 | /* harmony default export */ var Strict_takeWhile = (curry(function takeWhile(f, iter) { 1629 | let res = []; 1630 | iter = toIter(iter); 1631 | return function recur() { 1632 | let cur; 1633 | while (!(cur = iter.next()).done) { 1634 | const a = cur.value; 1635 | const b = go1(a, a => f(a, res)); 1636 | if (!b) return res; 1637 | if (b instanceof Promise) { 1638 | return b 1639 | .then(async b => b ? (res.push(await a), recur()) : res) 1640 | .catch(e => e == Strict_nop ? recur() : Promise.reject(e)); 1641 | } 1642 | res.push(a); 1643 | } 1644 | return res; 1645 | } (); 1646 | })); 1647 | // CONCATENATED MODULE: ./Strict/throttle.js 1648 | 1649 | 1650 | 1651 | /* harmony default export */ var Strict_throttle = (curry(function throttle(f, time) { 1652 | let block = false; 1653 | return function _throttle(...args) { 1654 | if (block) return; 1655 | block = true; 1656 | delay(time, null).then(_ => (block = false)); 1657 | return f(...args); 1658 | }; 1659 | })); 1660 | // CONCATENATED MODULE: ./Lazy/unionByLazy.js 1661 | 1662 | 1663 | 1664 | 1665 | 1666 | /* harmony default export */ var Lazy_unionByLazy = (curry(function unionByLazy(f, a, b) { 1667 | return go( 1668 | [a, b], 1669 | flatLazy, 1670 | Lazy_uniqueByLazy(f)) 1671 | })); 1672 | // CONCATENATED MODULE: ./Lazy/unionLazy.js 1673 | 1674 | 1675 | 1676 | 1677 | /* harmony default export */ var Lazy_unionLazy = (curry(function unionLazy(a, b) { 1678 | return Lazy_unionByLazy(identity, a, b); 1679 | })); 1680 | // CONCATENATED MODULE: ./Strict/union.js 1681 | 1682 | 1683 | 1684 | 1685 | 1686 | /* harmony default export */ var Strict_union = (curry(function union(a, b) { 1687 | return go1( 1688 | Lazy_unionLazy(a, b), 1689 | takeAll 1690 | ) 1691 | })); 1692 | // CONCATENATED MODULE: ./Strict/unionBy.js 1693 | 1694 | 1695 | 1696 | 1697 | 1698 | /* harmony default export */ var Strict_unionBy = (curry(function unionBy(f, a, b) { 1699 | return go1(Lazy_unionByLazy(f, a, b), takeAll); 1700 | })); 1701 | 1702 | // CONCATENATED MODULE: ./Strict/uniqueBy.js 1703 | 1704 | 1705 | 1706 | 1707 | 1708 | 1709 | 1710 | 1711 | /* harmony default export */ var Strict_uniqueBy = (curry(function uniqueBy(f, iter) { 1712 | return isIterable(iter) ? 1713 | takeAll(Lazy_uniqueByLazy(f, iter)) : 1714 | object_object(Lazy_uniqueByLazy(e => f(last(e)), entriesLazy(iter))); 1715 | })); 1716 | // CONCATENATED MODULE: ./Strict/unique.js 1717 | 1718 | 1719 | 1720 | function unique(a) { 1721 | return Strict_uniqueBy(identity, a); 1722 | } 1723 | // CONCATENATED MODULE: ./Lazy/takeWhileLazy.js 1724 | 1725 | 1726 | 1727 | 1728 | 1729 | 1730 | const resolved = Promise.resolve(); 1731 | /* harmony default export */ var Lazy_takeWhileLazy = (curry(function* takeWhileLazy(f, iter) { 1732 | let prev = resolved, ok = true; 1733 | for (const a of toIter(iter)) { 1734 | const _ok = ok && go1(a, f); 1735 | if (_ok instanceof Promise) { 1736 | _ok.catch(noop); 1737 | yield prev = prev.then(_ => _ok).then(_ok => (ok = _ok) ? a : Promise.reject(Strict_nop)); 1738 | prev = prev.catch(noop); 1739 | } else if (ok = _ok) { 1740 | yield a; 1741 | } 1742 | if (!ok) break; 1743 | } 1744 | })); 1745 | // CONCATENATED MODULE: ./Lazy/zipLazy.js 1746 | 1747 | 1748 | 1749 | 1750 | 1751 | 1752 | 1753 | 1754 | 1755 | /* harmony default export */ var Lazy_zipLazy = (curry(function zipLazy(...iterables) { 1756 | const iterators = Strict_map(toIter, iterables); 1757 | return go( 1758 | rangeLazy(Infinity), 1759 | Lazy_mapLazy(_ => Strict_map(it => it.next(), iterators)), 1760 | Lazy_takeWhileLazy(Strict_some(cur => !cur.done)), 1761 | Lazy_mapLazy(Strict_map(cur => cur.value))) 1762 | })); 1763 | // CONCATENATED MODULE: ./Strict/zip.js 1764 | 1765 | 1766 | 1767 | 1768 | 1769 | 1770 | /* harmony default export */ var Strict_zip = (curry(function zip(...iters) { 1771 | return go(iters, takeAll, apply(Lazy_zipLazy), takeAll); 1772 | })); 1773 | // CONCATENATED MODULE: ./Strict/unzip.js 1774 | 1775 | 1776 | function unzip(iter) { 1777 | return Strict_zip(...iter); 1778 | }; 1779 | // CONCATENATED MODULE: ./Strict/zipObj.js 1780 | 1781 | 1782 | 1783 | 1784 | /* harmony default export */ var Strict_zipObj = (curry(function zipObj(...iterables) { 1785 | return object_object(Lazy_zipLazy(...iterables)); 1786 | })); 1787 | // CONCATENATED MODULE: ./Strict/zipWith.js 1788 | 1789 | 1790 | 1791 | 1792 | /* harmony default export */ var Strict_zipWith = (curry(function zipWith(f, ...iterables) { 1793 | return Strict_map(group => f(...group), Lazy_zipLazy(...iterables)) 1794 | })); 1795 | // CONCATENATED MODULE: ./Strict/index.js 1796 | 1797 | 1798 | 1799 | 1800 | 1801 | 1802 | 1803 | 1804 | 1805 | 1806 | 1807 | 1808 | 1809 | 1810 | 1811 | 1812 | 1813 | 1814 | 1815 | 1816 | 1817 | 1818 | 1819 | 1820 | 1821 | 1822 | 1823 | 1824 | //ok 1825 | 1826 | 1827 | 1828 | 1829 | 1830 | 1831 | 1832 | 1833 | 1834 | 1835 | 1836 | 1837 | 1838 | 1839 | 1840 | 1841 | 1842 | 1843 | 1844 | 1845 | 1846 | 1847 | 1848 | 1849 | 1850 | 1851 | 1852 | 1853 | 1854 | 1855 | 1856 | 1857 | 1858 | 1859 | 1860 | 1861 | 1862 | 1863 | 1864 | 1865 | 1866 | 1867 | 1868 | 1869 | 1870 | 1871 | 1872 | 1873 | 1874 | 1875 | 1876 | 1877 | 1878 | 1879 | 1880 | 1881 | 1882 | 1883 | 1884 | 1885 | 1886 | 1887 | 1888 | 1889 | 1890 | 1891 | 1892 | 1893 | 1894 | 1895 | 1896 | 1897 | 1898 | 1899 | 1900 | 1901 | 1902 | 1903 | 1904 | 1905 | 1906 | 1907 | 1908 | 1909 | 1910 | // CONCATENATED MODULE: ./Lazy/compactLazy.js 1911 | 1912 | 1913 | /* harmony default export */ var compactLazy = (Lazy_filterLazy(a => a)); 1914 | // CONCATENATED MODULE: ./Lazy/concatLazy.js 1915 | 1916 | 1917 | /* harmony default export */ var concatLazy = (curry(function *concatLazy(a, b) { 1918 | yield* b; 1919 | yield* a; 1920 | })); 1921 | // CONCATENATED MODULE: ./Lazy/constantLazy.js 1922 | function* constantLazy(a) { yield a; } 1923 | // CONCATENATED MODULE: ./Lazy/flatMapLazy.js 1924 | 1925 | 1926 | 1927 | 1928 | /* harmony default export */ var Lazy_flatMapLazy = (curry(function flatMapLazy(f, iter) { 1929 | return flatLazy(Lazy_mapLazy(f, iter)); 1930 | })); 1931 | // CONCATENATED MODULE: ./Lazy/zipIndexs.js 1932 | 1933 | 1934 | function* zipIndexs(iter) { 1935 | let i = -1; 1936 | for (const a of toIter(iter)) yield [++i, a]; 1937 | }; 1938 | // CONCATENATED MODULE: ./Lazy/intervalLazy.js 1939 | 1940 | 1941 | 1942 | 1943 | function intervalLazy(time) { 1944 | return Lazy_mapLazy(delay(time), rangeLazy(Infinity)); 1945 | } 1946 | // CONCATENATED MODULE: ./Lazy/reverseLazy.js 1947 | function* reverseLazy(arr) { 1948 | var l = arr.length; 1949 | while (l--) yield arr[l]; 1950 | } 1951 | // CONCATENATED MODULE: ./Lazy/takeLazy.js 1952 | 1953 | 1954 | 1955 | 1956 | 1957 | /* harmony default export */ var Lazy_takeLazy = (curry(function* takeLazy(l, iter) { 1958 | if (l < 1) return; 1959 | let prev = null; 1960 | for (const a of toIter(iter)) { 1961 | if (a instanceof Promise) { 1962 | a.catch(noop); 1963 | yield prev = (prev || Promise.resolve()) 1964 | .then(_ => a) 1965 | .then(a => --l > -1 ? a : Promise.reject(Strict_nop)); 1966 | prev = prev.catch(noop); 1967 | } else { 1968 | yield (--l, a); 1969 | } 1970 | if (!l) break; 1971 | } 1972 | })); 1973 | // CONCATENATED MODULE: ./Lazy/index.js 1974 | 1975 | 1976 | 1977 | 1978 | 1979 | 1980 | 1981 | 1982 | 1983 | 1984 | 1985 | 1986 | 1987 | 1988 | 1989 | 1990 | 1991 | 1992 | 1993 | 1994 | 1995 | 1996 | 1997 | 1998 | 1999 | 2000 | 2001 | 2002 | 2003 | 2004 | 2005 | 2006 | 2007 | 2008 | 2009 | 2010 | 2011 | 2012 | 2013 | // CONCATENATED MODULE: ./.internal/catchNoop.js 2014 | function catchNoop(arr) { 2015 | arr.forEach(a => a instanceof Promise ? a.catch(function() {}) : a); 2016 | return arr; 2017 | } 2018 | 2019 | /* harmony default export */ var _internal_catchNoop = (catchNoop); 2020 | // CONCATENATED MODULE: ./Concurrency/takeC.js 2021 | 2022 | 2023 | 2024 | 2025 | /* harmony default export */ var Concurrency_takeC = (curry(function takeC(l, iter) { 2026 | return Strict_take(l, _internal_catchNoop([...iter])); 2027 | })); 2028 | // CONCATENATED MODULE: ./Concurrency/takeAllC.js 2029 | 2030 | 2031 | 2032 | 2033 | 2034 | 2035 | 2036 | 2037 | 2038 | 2039 | function takeAllC(n, iter) { 2040 | if (arguments.length == 1) return typeof n == 'number' ? _ => takeAllC(n, _) : Concurrency_takeC(Infinity, n); 2041 | iter = toIter(iter); 2042 | let closed = false; 2043 | return go( 2044 | rangeLazy(Infinity), 2045 | Lazy_mapLazy(_ => go( 2046 | rangeLazy(n), 2047 | Lazy_mapLazy(_ => iter.next()), 2048 | Strict_takeWhile(({done}) => !(closed = done)), 2049 | Strict_map(({value}) => value))), 2050 | Lazy_takeUntilLazy(_ => closed), 2051 | flat); 2052 | } 2053 | // CONCATENATED MODULE: ./Concurrency/mapC.js 2054 | 2055 | 2056 | 2057 | 2058 | /* harmony default export */ var Concurrency_mapC = (curry(function mapC(f, iter) { 2059 | return takeAllC(Lazy_mapLazy(f, iter)); 2060 | })); 2061 | // CONCATENATED MODULE: ./Concurrency/reduceC.js 2062 | 2063 | 2064 | 2065 | 2066 | /* harmony default export */ var Concurrency_reduceC = (curry(function reduceC(f, acc, iter) { 2067 | return arguments.length == 2 ? 2068 | reduce(f, _internal_catchNoop([...acc])) : 2069 | reduce(f, acc, _internal_catchNoop([...iter])); 2070 | })); 2071 | // CONCATENATED MODULE: ./Concurrency/objectC.js 2072 | 2073 | 2074 | function objectC(iter) { 2075 | return Concurrency_reduceC((obj, [k, v]) => (obj[k] = v, obj), {}, iter); 2076 | } 2077 | // CONCATENATED MODULE: ./Concurrency/callsC.js 2078 | 2079 | 2080 | 2081 | 2082 | /* harmony default export */ var callsC = (_internal_baseCalls(Concurrency_mapC, objectC)); 2083 | // CONCATENATED MODULE: ./Concurrency/filterC.js 2084 | 2085 | 2086 | 2087 | 2088 | /* harmony default export */ var Concurrency_filterC = (curry(function filterC(f, iter) { 2089 | return takeAllC(Lazy_filterLazy(f, iter)); 2090 | })); 2091 | // CONCATENATED MODULE: ./Concurrency/compactC.js 2092 | 2093 | 2094 | /* harmony default export */ var compactC = (Concurrency_filterC(a => a)); 2095 | // CONCATENATED MODULE: ./Concurrency/dropC.js 2096 | 2097 | 2098 | 2099 | 2100 | /* harmony default export */ var Concurrency_dropC = (curry(function dropC(l, iter) { 2101 | return Strict_drop(l, _internal_catchNoop([...iter])); 2102 | })); 2103 | // CONCATENATED MODULE: ./Concurrency/everyC.js 2104 | 2105 | 2106 | 2107 | 2108 | 2109 | 2110 | 2111 | /* harmony default export */ var Concurrency_everyC = (curry(function everyC(f, iter) { 2112 | return go( 2113 | Lazy_mapLazy(f, iter), 2114 | Lazy_takeUntilLazy(not), 2115 | Concurrency_reduceC((a, b) => a && b), 2116 | (a = false) => a, 2117 | Boolean); 2118 | })); 2119 | // CONCATENATED MODULE: ./Concurrency/headC.js 2120 | 2121 | 2122 | 2123 | function headC(iter) { 2124 | return go1(Concurrency_takeC(1, iter), ([h]) => h); 2125 | } 2126 | // CONCATENATED MODULE: ./Concurrency/findC.js 2127 | 2128 | 2129 | 2130 | 2131 | /* harmony default export */ var Concurrency_findC = (curry(function findC(f, iter) { 2132 | return headC(Lazy_filterLazy(f, iter)); 2133 | })); 2134 | // CONCATENATED MODULE: ./Concurrency/mapEntriesC.js 2135 | 2136 | 2137 | 2138 | 2139 | /* harmony default export */ var Concurrency_mapEntriesC = (curry(async function mapEntriesC(f, iter) { 2140 | return takeAllC(Lazy_mapEntriesLazy(f, iter)); 2141 | })); 2142 | // CONCATENATED MODULE: ./Concurrency/takeRaceC.js 2143 | 2144 | 2145 | 2146 | /* harmony default export */ var Concurrency_takeRaceC = (curry(function takeRaceC(l, iter) { 2147 | return new Promise((resolve, reject) => { 2148 | let res = []; 2149 | Promise.all([...iter].map(async a => { 2150 | try { 2151 | const b = await a; 2152 | res.push(b); 2153 | if (res.length == l) resolve(res); 2154 | return b; 2155 | } catch (e) { 2156 | if (e != Strict_nop) throw e; 2157 | } 2158 | })).then(_ => resolve(res)).catch(reject); 2159 | }) 2160 | })); 2161 | // CONCATENATED MODULE: ./Concurrency/raceC.js 2162 | 2163 | 2164 | async function raceC(iter) { 2165 | return (await Concurrency_takeRaceC(1, iter))[0]; 2166 | }; 2167 | // CONCATENATED MODULE: ./Concurrency/someC.js 2168 | 2169 | 2170 | 2171 | 2172 | 2173 | 2174 | 2175 | /* harmony default export */ var Concurrency_someC = (curry(function someC(f, iter) { 2176 | return go( 2177 | Lazy_mapLazy(f, iter), 2178 | Lazy_takeUntilLazy(identity), 2179 | Concurrency_reduceC((a, b) => a || b), 2180 | (a = false) => a, 2181 | Boolean); 2182 | })); 2183 | // CONCATENATED MODULE: ./Concurrency/tailC.js 2184 | 2185 | 2186 | function tailC(iter) { 2187 | return Concurrency_dropC(1, iter); 2188 | } 2189 | // CONCATENATED MODULE: ./Concurrency/take1C.js 2190 | 2191 | 2192 | /* harmony default export */ var take1C = (Concurrency_takeC(1)); 2193 | // CONCATENATED MODULE: ./Concurrency/index.js 2194 | 2195 | 2196 | 2197 | 2198 | 2199 | 2200 | 2201 | 2202 | 2203 | 2204 | 2205 | 2206 | 2207 | 2208 | 2209 | 2210 | 2211 | 2212 | // CONCATENATED MODULE: ./entry.js 2213 | 2214 | 2215 | 2216 | 2217 | const L = { ...Lazy_namespaceObject }; 2218 | const C = { ...Concurrency_namespaceObject }; 2219 | 2220 | window.fx = window._ = { ...Strict_namespaceObject, L, C }; 2221 | window.C = C; 2222 | window.L = L; 2223 | 2224 | /***/ }) 2225 | /******/ ]); 2226 | //# sourceMappingURL=fx.js.map --------------------------------------------------------------------------------