From 3fd3f4fcdae474b30d12283053f864b7bc087c12 Mon Sep 17 00:00:00 2001
From: Foysal Ahmed <fashuvo@MacBook-Pro.local>
Date: Thu, 18 Aug 2022 18:03:27 +0600
Subject: [PATCH 1/3] Add dummy text

---
 index.html | 55 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/index.html b/index.html
index 19e745d..b6dba79 100644
--- a/index.html
+++ b/index.html
@@ -65,6 +65,61 @@ <h1>eWallet</h1>
       <div class="collection"></div>
     </div>
 
+    <p>
+      
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Morbi tempor urna tortor, et convallis massa dapibus in. Aenean non vestibulum felis. Phasellus iaculis placerat interdum. Sed vitae porta orci, sit amet cursus felis. Ut faucibus lectus sed enim hendrerit, nec feugiat nisl condimentum. Aenean rutrum scelerisque orci, at facilisis arcu viverra porttitor. Phasellus et dictum leo. Sed ornare consequat rhoncus. Morbi quis sagittis neque. Vivamus auctor elementum tempor.
+
+Nam aliquam a dolor nec viverra. Quisque commodo laoreet rhoncus. Quisque eu diam ante. Ut ac dolor dui. Curabitur ultrices aliquam justo quis dapibus. Nunc eleifend at eros vel molestie. Curabitur ornare, mi non facilisis pellentesque, orci urna varius magna, quis eleifend mi lorem ut velit.
+
+Donec id tortor justo. Cras eu lacinia odio. Maecenas sit amet est auctor, placerat sapien vehicula, fringilla dui. Aliquam semper venenatis nulla in dapibus. Vivamus ultricies nulla at mauris posuere ullamcorper. Cras suscipit neque sed ipsum lobortis sagittis. Vivamus rhoncus vehicula mi, in tincidunt lorem. Phasellus eget augue fringilla, maximus odio sit amet, sodales elit. Donec auctor in elit ut ultricies. Nam et dui arcu. Fusce in orci eget nibh auctor elementum. Aenean ac vestibulum augue.
+
+Donec ornare magna eros, sed vehicula ligula tincidunt vitae. Mauris et justo vitae lacus accumsan hendrerit id in velit. Curabitur hendrerit iaculis ex eget feugiat. Sed eu ante facilisis, congue augue tempus, dapibus ante. Sed lobortis quam eu ipsum porttitor, accumsan lobortis nisi sagittis. Suspendisse potenti. Morbi mattis vitae ipsum eu pulvinar. Nullam a arcu pellentesque, vehicula nibh in, elementum magna. Etiam at orci felis.
+
+Ut sit amet mollis turpis, vel condimentum nisi. Nullam id lectus efficitur, elementum erat quis, rhoncus libero. Morbi sit amet mi consequat, maximus ligula non, ullamcorper elit. Nunc cursus dolor sed malesuada efficitur. Mauris eu arcu congue ex bibendum congue. Sed sodales auctor tortor. Nam augue sem, pulvinar et urna sit amet, tristique feugiat arcu. Ut aliquet vel risus sollicitudin mattis. Donec sit amet interdum urna. Sed feugiat vestibulum urna, in tincidunt magna lacinia id. Etiam et sapien quis felis commodo pulvinar. Duis viverra in libero vitae pretium. Nunc aliquam gravida neque, sit amet commodo magna tincidunt eget. Nullam id metus rhoncus, rhoncus ante a, hendrerit quam.
+
+Phasellus finibus iaculis sagittis. Aliquam malesuada fermentum massa, eget condimentum mi tincidunt eget. Nam mi elit, molestie id tincidunt non, efficitur ut mauris. Pellentesque sagittis orci id nisi consequat finibus. Suspendisse egestas fringilla mi, consectetur porttitor erat cursus nec. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Sed in quam sit amet orci dignissim molestie. Quisque semper libero quis maximus faucibus. In laoreet quam eu nisl molestie, sed pharetra diam suscipit. Aliquam et bibendum magna. Morbi accumsan ut tortor vel luctus. Morbi eu accumsan ligula, eu condimentum leo. Etiam pretium lacus eros, ut malesuada nunc mollis vel.
+
+Morbi id iaculis massa. Morbi lobortis dui est, quis efficitur augue porta tristique. Donec commodo nisl eu enim tincidunt lacinia. Praesent tincidunt augue mi, nec porttitor libero consectetur vitae. Nam tellus lectus, cursus eget euismod a, feugiat in tortor. Aenean eget sodales lorem. Curabitur et eleifend massa, id elementum ante. Sed aliquam vehicula sem, sed luctus sem auctor et. Fusce vestibulum, enim ac ullamcorper viverra, lectus elit iaculis eros, consequat sollicitudin lorem dolor nec lacus. Vivamus cursus lobortis felis eu pulvinar. Vestibulum ac velit at nunc faucibus interdum. Praesent nulla nisl, cursus et turpis ac, pellentesque feugiat justo. Praesent malesuada ultricies porta. Etiam mattis arcu ut libero pharetra sagittis. Quisque pharetra et dui ut lacinia.
+
+Duis et dictum dolor. Donec sollicitudin augue sit amet diam condimentum, non volutpat felis lobortis. Proin congue id nibh ultricies malesuada. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Sed neque mi, volutpat id orci id, imperdiet vestibulum nisl. Nullam laoreet mauris mauris, vel facilisis metus posuere et. Nunc in porttitor enim, sollicitudin fermentum libero. Duis auctor ac elit ac vehicula. Fusce erat sem, finibus in ultrices eu, pulvinar vitae erat. Curabitur sit amet metus scelerisque, ultrices magna eu, finibus nisl. Sed ut magna suscipit, ultrices dui at, porttitor nisl. Phasellus tempus bibendum erat in iaculis.
+
+Duis sit amet ante et quam pretium eleifend eu id risus. Nam eu molestie dui, sed vehicula tortor. Interdum et malesuada fames ac ante ipsum primis in faucibus. Nam eros dolor, elementum tristique sapien sed, consectetur cursus sapien. Praesent ut sollicitudin elit, eu cursus mauris. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Morbi faucibus dapibus lorem, quis finibus ante luctus sit amet. Donec eleifend nisl blandit posuere cursus. Suspendisse consectetur sit amet arcu a mattis.
+
+Fusce quam elit, gravida at orci et, accumsan maximus sapien. Vestibulum tristique rhoncus turpis, vitae tempus nisl aliquam id. Integer porttitor turpis diam, quis pretium urna euismod sit amet. Quisque volutpat euismod magna, lobortis accumsan nulla vehicula sed. Maecenas tristique eros ante, at vulputate enim bibendum laoreet. Nullam ut suscipit risus, vel euismod enim. Sed gravida volutpat sapien, vitae condimentum dolor euismod a. Suspendisse rhoncus eros vitae odio posuere ultrices. Quisque ac efficitur felis, pellentesque dapibus arcu. Sed fermentum felis ut pulvinar scelerisque.
+
+Nullam lobortis consectetur sodales. Nam id scelerisque dui. Interdum et malesuada fames ac ante ipsum primis in faucibus. Maecenas aliquam tristique nulla, a dignissim nulla faucibus malesuada. In sodales erat vel arcu dapibus pellentesque. Proin molestie eu lectus nec ultrices. Sed at ultrices nulla, non faucibus nisi. Donec ullamcorper consectetur sapien nec scelerisque. Vestibulum eu nisl dignissim, faucibus elit sed, pharetra augue. Aliquam ac ullamcorper libero, a aliquam velit.
+
+Sed vitae imperdiet augue. Aliquam interdum felis ut mattis fermentum. Aenean tempus, purus eu aliquet imperdiet, erat purus tempor eros, eget condimentum dolor est eget magna. Nullam in maximus eros, sit amet lacinia massa. Mauris vitae volutpat ex, ut egestas leo. Phasellus congue scelerisque neque, eu interdum sem laoreet a. Nullam in lectus et mi scelerisque ullamcorper. Suspendisse placerat pulvinar neque, vel tempor lectus sodales eget. Sed lobortis magna non nisl bibendum, nec pulvinar eros convallis.
+
+Aliquam erat volutpat. Cras fermentum suscipit elit in sodales. Donec ut rhoncus est, vitae luctus lorem. Quisque consequat neque eu aliquam pretium. In sit amet tellus neque. Nulla congue metus erat, quis consequat odio accumsan et. Sed accumsan suscipit ex. In varius erat massa, id aliquet enim convallis eleifend. Phasellus posuere convallis consectetur. Nunc vestibulum mi et massa varius laoreet. Aenean augue diam, ornare a purus a, placerat mattis orci. Quisque efficitur tristique euismod. Aliquam suscipit magna venenatis, auctor nibh quis, eleifend ante. In interdum ultrices augue, eu condimentum neque suscipit consectetur. Curabitur auctor, erat ut consectetur congue, nibh ipsum ultrices risus, sed bibendum sapien purus a libero. Vestibulum dui leo, molestie id lobortis nec, maximus et felis.
+
+Aenean eget pellentesque urna. Nullam ac finibus tellus, at viverra ligula. Sed eu velit nec tortor tempor varius quis id nisi. Curabitur scelerisque placerat neque, sit amet pharetra tortor gravida non. Phasellus pretium tristique diam, id hendrerit felis euismod vel. Vivamus ultricies sem quis quam pellentesque, eget aliquam justo lobortis. Phasellus lacinia lacus eget ligula molestie, vitae efficitur odio fringilla.
+
+Maecenas fermentum neque sit amet libero pretium, nec mollis nibh viverra. Nullam convallis feugiat arcu. Maecenas at orci eget tellus ultricies euismod. Mauris porttitor tortor non ex varius tristique. Morbi et commodo diam, sit amet ultricies libero. Suspendisse consectetur, ipsum eu pellentesque tempor, dui lacus mattis risus, eget vulputate nisl tortor nec sem. Fusce tincidunt enim varius tempus vehicula.
+
+Morbi volutpat libero id ex condimentum, vitae pretium risus aliquet. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut bibendum congue lacus, sed pulvinar leo eleifend ut. Sed feugiat ipsum malesuada leo lobortis, at cursus tortor porttitor. Fusce fringilla a tortor ac interdum. Proin volutpat tortor ante, in interdum tellus euismod a. Duis vitae sagittis sapien, ac rutrum lectus.
+
+Pellentesque augue diam, euismod sit amet auctor eu, fringilla vel mi. Nulla in mollis urna. Cras nec massa eu lectus malesuada elementum. Ut vitae tristique risus. Donec eget bibendum augue. Ut condimentum nunc sem, eu pretium tellus convallis sit amet. Etiam a commodo orci. Integer rutrum velit mi, dapibus fermentum diam egestas ut. Donec ac sem tempus, lobortis lorem at, viverra lectus. Aliquam placerat bibendum magna non consectetur. Sed eu quam vitae felis mattis laoreet vel eu nisl. Nullam semper pulvinar tortor vitae mollis. Aliquam mollis justo lorem, at convallis enim fermentum sit amet.
+
+Maecenas nulla purus, gravida a nunc ac, gravida vulputate ligula. Vivamus feugiat vitae erat id lacinia. Morbi eu condimentum massa. Fusce luctus libero non elit vehicula imperdiet sit amet vel nunc. Nunc placerat, augue a imperdiet luctus, lorem felis dictum mi, nec rhoncus mi ligula vel justo. Nam tempus volutpat leo, in vulputate tortor semper non. Fusce sodales nisl non nisl auctor placerat.
+
+Suspendisse mollis consectetur accumsan. Maecenas porttitor ligula in massa finibus aliquam. Praesent at commodo metus. Praesent consectetur fermentum lorem sed facilisis. Aenean eu luctus sapien. Cras efficitur dictum leo, ac pellentesque lacus mollis sed. Mauris aliquet porttitor ligula, sed tristique enim volutpat sit amet.
+
+Phasellus feugiat dolor quam, quis volutpat lacus sodales ac. Proin consectetur nisl eu purus volutpat condimentum. Sed sodales ullamcorper augue a ornare. Mauris a dignissim diam. Mauris eu turpis commodo, aliquam leo nec, vehicula odio. Nullam ac varius leo. Nulla tempor, dolor in iaculis aliquet, turpis neque aliquam sem, sit amet semper arcu neque vel nulla. Mauris in metus sed libero elementum sodales ac eget risus. Duis rhoncus, elit et luctus tempor, ante leo malesuada tellus, luctus tempus ligula est fringilla dolor. Sed elementum, ipsum ac pellentesque mollis, sapien ipsum consequat lacus, id condimentum est lacus id sapien. In magna urna, eleifend sit amet posuere at, cursus in tellus.
+
+Nulla pellentesque augue ex. Proin ut ipsum libero. Phasellus tristique risus in ipsum pharetra, in rhoncus quam mattis. Cras ultricies ipsum eget turpis porttitor, a sodales augue dignissim. Praesent ac leo sem. Sed enim sem, dapibus in odio quis, aliquam dictum quam. Phasellus ullamcorper urna ac tincidunt placerat. Praesent a elit enim. Ut ut lectus non nulla ullamcorper viverra ac sed magna. Cras pretium ante eu tellus laoreet, quis aliquet leo feugiat. Suspendisse non magna a nisl bibendum aliquet vel at nisi. Sed faucibus, lectus ut eleifend feugiat, felis mi semper augue, eu facilisis ex dolor in dui. Donec ipsum massa, convallis et turpis vel, pharetra faucibus ex. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Donec id velit a augue porta malesuada. Maecenas nec pretium orci.
+
+Proin faucibus ullamcorper laoreet. Quisque felis tellus, bibendum ut diam a, gravida luctus nibh. Aliquam erat volutpat. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Donec ac faucibus augue. Nam quis convallis ante. Vestibulum gravida sem consequat cursus suscipit. Nullam efficitur tincidunt enim, quis condimentum odio maximus eu. Etiam pretium sapien eget gravida posuere. Vivamus scelerisque eros sed dictum mollis. Nullam euismod nunc eros, fermentum faucibus risus euismod ac. Ut non viverra ligula, in eleifend felis. Phasellus sollicitudin, nisl sit amet ornare imperdiet, justo est commodo elit, interdum dignissim velit dui quis enim. Aliquam a sapien vitae turpis tempor imperdiet eu in ligula.
+
+Proin nec massa nec augue aliquam vestibulum. Morbi sagittis sit amet purus et vehicula. Maecenas feugiat mollis justo, vel fringilla ipsum. Nunc nec porta diam. Aenean accumsan lobortis leo, eget volutpat felis tincidunt eget. Nullam a est enim. Sed in neque id augue tempor varius at a dolor. Donec venenatis purus eu eros faucibus posuere. Fusce tellus lorem, feugiat eu tempor eget, interdum quis elit. Fusce venenatis nulla eget dapibus dapibus. Vestibulum quis dui elementum, gravida dolor a, consequat augue. In id arcu et odio hendrerit suscipit eget vel metus. Maecenas convallis vestibulum purus eget lobortis. Curabitur nunc risus, egestas et magna sed, rhoncus sollicitudin urna. Ut vitae vehicula ante.
+
+Duis consectetur purus eu consequat finibus. Vivamus placerat massa ac massa dictum dictum. Mauris efficitur non arcu vitae convallis. Nullam risus eros, vehicula vel mollis at, mollis eu ante. Donec scelerisque, erat vitae feugiat suscipit, lectus eros mattis dolor, id pretium leo mi id odio. Quisque eget lorem vitae turpis vehicula commodo. Cras a fermentum sapien. Maecenas maximus odio sit amet urna bibendum lacinia. Sed blandit sit amet purus in scelerisque. Quisque lobortis dapibus fermentum. Aliquam id lorem non velit facilisis condimentum. Sed facilisis ac mauris eget pharetra. Curabitur gravida rutrum nisi, nec volutpat lectus. Nullam fringilla nibh ut tincidunt ultricies. Suspendisse potenti.
+
+Etiam consequat sapien sed felis gravida, vitae interdum diam eleifend. Fusce quis orci ultrices, ornare nulla quis, egestas dolor. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer dignissim, quam in fringilla ultrices, ex leo tempus nisi, in tristique turpis enim sed felis. Quisque sed fermentum tellus. Suspendisse potenti. Integer volutpat erat et sem efficitur lobortis. Nulla enim sem, porttitor ut aliquam id, bibendum sed libero. Ut sit amet varius turpis. Aenean mattis erat sed vehicula blandit. Proin efficitur commodo scelerisque. Mauris risus eros, tristique sollicitudin magna at, auctor fermentum lectus. Praesent cursus cursus ultrices. Suspendisse quis ornare enim. Suspendisse sollicitudin, ligula at porta dignissim, nunc ligula faucibus felis, sit amet dignissim nibh ipsum in risus. Duis consectetur vel elit et finibus.
+
+Generated 25 paragraphs, 2170 words, 14649 b
+    </p>
+
     <script
       type="module"
       src="https://unpkg.com/ionicons@5.0.0/dist/ionicons/ionicons.esm.js"

From c19d31b824cc54868830de1fb7f7f85bd33e810d Mon Sep 17 00:00:00 2001
From: Foysal Ahmed <fashuvo@MacBook-Pro.local>
Date: Thu, 18 Aug 2022 18:10:50 +0600
Subject: [PATCH 2/3] Add files

---
 main.yml                                    |   11 +
 node_modules/.package-lock.json             |   13 +
 node_modules/list/LICENSE                   |   22 +
 node_modules/list/README.md                 | 1434 ++++++++++++++++
 node_modules/list/curried/package.json      |    7 +
 node_modules/list/dist/curried.d.ts         |  110 ++
 node_modules/list/dist/curried.js           |  121 ++
 node_modules/list/dist/devtools.d.ts        |    1 +
 node_modules/list/dist/devtools.js          |   46 +
 node_modules/list/dist/es/curried.d.ts      |  110 ++
 node_modules/list/dist/es/curried.js        |   97 ++
 node_modules/list/dist/es/devtools.d.ts     |    1 +
 node_modules/list/dist/es/devtools.js       |   44 +
 node_modules/list/dist/es/fantasy-land.d.ts |   15 +
 node_modules/list/dist/es/fantasy-land.js   |   34 +
 node_modules/list/dist/es/index.d.ts        |  115 ++
 node_modules/list/dist/es/index.js          | 1627 ++++++++++++++++++
 node_modules/list/dist/es/methods.d.ts      |   79 +
 node_modules/list/dist/es/methods.js        |  212 +++
 node_modules/list/dist/es/ramda.d.ts        |   65 +
 node_modules/list/dist/es/ramda.js          |   67 +
 node_modules/list/dist/fantasy-land.d.ts    |   15 +
 node_modules/list/dist/fantasy-land.js      |   39 +
 node_modules/list/dist/index.d.ts           |  115 ++
 node_modules/list/dist/index.js             | 1704 +++++++++++++++++++
 node_modules/list/dist/methods.d.ts         |   79 +
 node_modules/list/dist/methods.js           |  217 +++
 node_modules/list/dist/ramda.d.ts           |   66 +
 node_modules/list/dist/ramda.js             |   72 +
 node_modules/list/fantasy-land/package.json |    7 +
 node_modules/list/methods/package.json      |    7 +
 node_modules/list/package.json              |   92 +
 node_modules/list/ramda/package.json        |    7 +
 package-lock.json                           |   28 +
 package.json                                |   25 +
 35 files changed, 6704 insertions(+)
 create mode 100644 main.yml
 create mode 100644 node_modules/.package-lock.json
 create mode 100644 node_modules/list/LICENSE
 create mode 100644 node_modules/list/README.md
 create mode 100644 node_modules/list/curried/package.json
 create mode 100644 node_modules/list/dist/curried.d.ts
 create mode 100644 node_modules/list/dist/curried.js
 create mode 100644 node_modules/list/dist/devtools.d.ts
 create mode 100644 node_modules/list/dist/devtools.js
 create mode 100644 node_modules/list/dist/es/curried.d.ts
 create mode 100644 node_modules/list/dist/es/curried.js
 create mode 100644 node_modules/list/dist/es/devtools.d.ts
 create mode 100644 node_modules/list/dist/es/devtools.js
 create mode 100644 node_modules/list/dist/es/fantasy-land.d.ts
 create mode 100644 node_modules/list/dist/es/fantasy-land.js
 create mode 100644 node_modules/list/dist/es/index.d.ts
 create mode 100644 node_modules/list/dist/es/index.js
 create mode 100644 node_modules/list/dist/es/methods.d.ts
 create mode 100644 node_modules/list/dist/es/methods.js
 create mode 100644 node_modules/list/dist/es/ramda.d.ts
 create mode 100644 node_modules/list/dist/es/ramda.js
 create mode 100644 node_modules/list/dist/fantasy-land.d.ts
 create mode 100644 node_modules/list/dist/fantasy-land.js
 create mode 100644 node_modules/list/dist/index.d.ts
 create mode 100644 node_modules/list/dist/index.js
 create mode 100644 node_modules/list/dist/methods.d.ts
 create mode 100644 node_modules/list/dist/methods.js
 create mode 100644 node_modules/list/dist/ramda.d.ts
 create mode 100644 node_modules/list/dist/ramda.js
 create mode 100644 node_modules/list/fantasy-land/package.json
 create mode 100644 node_modules/list/methods/package.json
 create mode 100644 node_modules/list/package.json
 create mode 100644 node_modules/list/ramda/package.json
 create mode 100644 package-lock.json
 create mode 100644 package.json

diff --git a/main.yml b/main.yml
new file mode 100644
index 0000000..03b499d
--- /dev/null
+++ b/main.yml
@@ -0,0 +1,11 @@
+name: Compressed Size
+
+on: [pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: preactjs/compressed-size-action@v2
diff --git a/node_modules/.package-lock.json b/node_modules/.package-lock.json
new file mode 100644
index 0000000..fab9933
--- /dev/null
+++ b/node_modules/.package-lock.json
@@ -0,0 +1,13 @@
+{
+  "name": "ewallet",
+  "version": "1.0.0",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {
+    "node_modules/list": {
+      "version": "2.0.19",
+      "resolved": "https://registry.npmjs.org/list/-/list-2.0.19.tgz",
+      "integrity": "sha512-nnVaRp4RaMAQkCpypTThsdxKqgPMiSwJq93eAm2/IbpUa8sd04XKBhkKu+bMk63HmdjK8b8Cuh4xARHWX2ye/Q=="
+    }
+  }
+}
diff --git a/node_modules/list/LICENSE b/node_modules/list/LICENSE
new file mode 100644
index 0000000..05d4d63
--- /dev/null
+++ b/node_modules/list/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2016-2018 Simon Friis Vindum
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
diff --git a/node_modules/list/README.md b/node_modules/list/README.md
new file mode 100644
index 0000000..a7a571f
--- /dev/null
+++ b/node_modules/list/README.md
@@ -0,0 +1,1434 @@
+<h3 align="center">
+  <img align="center" src="assets/listopard.png" alt="List logo" width=400 />
+</h3>
+
+<p align="center">
+A fast immutable list with a functional API.
+</p>
+
+<p align="center">
+  <a href="https://gitter.im/funkia/General"><img src="https://img.shields.io/gitter/room/funkia/General.svg" alt="Gitter" height="20"></a>
+  <a href="https://travis-ci.org/funkia/list"><img src="https://travis-ci.org/funkia/list.svg?branch=master" alt="Build Status" height="20"></a>
+  <a href="https://codecov.io/gh/funkia/list"><img src="https://codecov.io/gh/funkia/list/branch/master/graph/badge.svg" alt="codecov" height="20"></a>
+</p>
+
+# List
+
+List is a purely functional alternative to arrays. It is an
+implementation of a fast persistent sequence data structure. Compared
+to JavaScript's `Array` List has three major benefits.
+
+* **Safety**. List is immutable. This makes it safer and better suited
+  for functional programming. It doesn't tempt you with an imperative API and
+  accidental mutations won't be a source of bugs.
+* **Performance**. Since List doesn't allow mutations it can be
+  heavily optimized for pure operations. This makes List much faster for
+  functional programming than arrays. [See the
+  benchmarks](https://funkia.github.io/list/benchmarks/).
+* **API**: List has a large API of useful functions and offers both chainable
+  methods and curried functions to suit every taste.
+
+## Features
+
+* **Familiar functional API**. List follows the naming conventions
+  common in functional programming and has arguments ordered for
+  currying/partial application.
+* **Extensive API**. List has all the functions known from `Array`
+  and a lot of additional functions that'll save the day once you need them.
+* **Extremely fast**. List is a carefully optimized implementation of
+  the highly efficient data-structure _relaxed radix balanced trees_. We have
+  an [extensive benchmark suite](https://funkia.github.io/list/benchmarks/) to
+  ensure optimal performance. Here is an explanation [how](http://vindum.io/blog/how-can-list-be-faster-than-native-arrays/)
+* **Several API styles**. In addition to the base API List offers [additional
+  API styles](#api-styles). Import `list/methods` to get chainable methods or
+  alterntively import `list/curried` to get a version of the API where every
+  function is curried. Both variants are 100% TypeScript compatible.
+* **Does one thing well**. Instead of offering a wealth of data
+  structures List has a tight focus on being the best immutable list possible.
+  It doesn't do everything but is designed to work well with the libraries
+  you're already using.
+* **Seamless Ramda integration**. If you know Ramda you already know
+  how to use List. List was designed to integrate [seamlessly with
+  Ramda](#seamless-ramda-integration).
+* **Type safe**. List is implemented in TypeScript. It makes full use of
+  TypeScript features to provide accurate types that covers the entire library.
+* **Fully compatible with tree-shaking**. List ships with tree-shaking
+  compatible ECMAScript modules. `import * as L from "list"` in itself adds
+  zero bytes to your bundle when using Webpack. Using a function adds only that
+  function and the very small (<1KB) core of the library. You only pay in size
+  for the functions that you actually use.
+* **Iterable**. Implements the JavaScript iterable protocol. This
+  means that lists can be use in `for..of` loops, works with destructuring, and
+  can be passed to any function expecting an iterable. [See more](#iterable).
+* **Fantasy Land support**. List
+  [implements](#fantasy-land--static-land) both the Fantasy Land and the Static
+  Land specification.
+
+| Package | Version                                                                                 | Downloads                                                                                  | Dependencies                                                                                          | Dev Deps                                                                                                              | Install size                                                                                             | GZIP size                                                                                                                                                 |
+| ------- | --------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `list`  | [![npm version](https://badge.fury.io/js/list.svg)](https://www.npmjs.com/package/list) | [![Downloads](https://img.shields.io/npm/dt/list.svg)](https://www.npmjs.com/package/list) | [![Dependency Status](https://david-dm.org/funkia/list/status.svg)](https://david-dm.org/funkia/list) | [![devDependency Status](https://david-dm.org/funkia/list/dev-status.svg)](https://david-dm.org/funkia/list?type=dev) | [![install size](https://packagephobia.now.sh/badge?p=list)](https://packagephobia.now.sh/result?p=list) | [![gzip size](http://img.badgesize.io/https://cdn.jsdelivr.net/npm/list/dist/index.js?compression=gzip)](https://cdn.jsdelivr.net/npm/list/dist/index.js) |
+
+
+## Getting started
+
+This section explains how to get started using List. First you'll have
+to install the library.
+
+```
+npm i list
+```
+
+Then you can import it.
+
+```js
+// As an ES module
+import * as L from "list";
+// Or with require
+const L = require("list");
+```
+
+Then you can begin using List instead of arrays and enjoy immutability
+the performance benefits.
+
+As a replacement for array literals List offers the function `list`
+for constructing lists. Instead of using `[...]` to construct an array
+with the content `...` one can use `list(...)` to construct a list
+with the same content. Here is an example.
+
+
+```js
+// An array literal
+const myArray = [0, 1, 2, 3];
+// The List equivalent
+const myList = L.list(0, 1, 2, 3);
+```
+
+List has all the common functions that you know from native arrays and
+other libraries.
+
+```js
+const myList = L.list(0, 1, 2, 3, 4, 5);
+myList.length; //=> 6
+L.filter(isEven, myList); //=> list(0, 2, 4)
+L.map(n => n * n, myList); //=> list(0, 1, 4, 9, 16, 25)
+L.reduce((sum, n) => sum + n, 0, myList); //=> 15
+L.slice(2, 5, myList); //=> list(2, 3, 4)
+L.concat(myList, L.list(6, 7, 8)); //=> list(0, 1, 2, 3, 4, 5, 6, 7, 8);
+```
+
+You'll probably also end up needing to convert between arrays and
+List. You can do that with the functions `from` and `toArray`.
+
+```js
+L.toArray(L.list("foo", "bar")); //=> ["foo", "bar"];
+L.from(["foo", "bar"]); //=> L.list("foo", "bar");
+```
+
+List offers a wealth of other useful and high-performing functions.
+You can see them all in the [API documentation](#api-documentation)
+
+## API styles
+
+List offers several API styles. By default the library exports "plain"
+functions. Additionally curried functions can be imported from `list/curried`
+and an API with chainable methods can be imported from `list/methods`. The
+differences are illustrated below.
+
+The default export offers normal plain function.
+
+```ts
+import * as L from "list";
+
+const l = take(5, sortBy(p => p.name, filter(p => p.age > 22, people)));
+```
+
+In `list/methods` all functions are available as chainable methods.
+
+```ts
+import * as L from "list/methods";
+
+const l = people
+  .filter(p => p.age > 22)
+  .sortBy(p => p.name)
+  .take(5);
+```
+
+In `list/curried` all functions are curried. In the example below the partially
+applied functions are composed together using Ramda's
+[`pipe`](http://ramdajs.com/docs/#pipe). Alternatively one could have used
+Lodash's [`flowRight`](https://lodash.com/docs/#flow).
+
+```ts
+import * as R from "ramda";
+import * as L from "list/curried";
+
+const l = R.pipe(L.filter(p => p.age > 22), L.sortBy(p => p.name), L.take(5))(
+  people
+);
+```
+
+## Iterable
+
+List implements the JavaScript iterable protocol. This means that
+lists can be used with array destructuring just like normal arrays.
+
+```js
+const myList = L.list("first", "second", "third", "fourth");
+const [first, second] = myList;
+first; //=> "first"
+second; //=> "second"
+```
+
+Lists can also be used in `for..of` loops.
+
+```js
+for (const element of myList) {
+  console.log(element);
+}
+// logs: first, second, third, fourth
+```
+
+And they can be passed to any function that takes an iterable as its argument.
+As an example a list can be converted into a native
+[`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set).
+
+```js
+const mySet = new Set(myList);
+mySet.has("third"); //=> true
+```
+
+This works because the `Set` constructor accepts any iterable as
+argument.
+
+Lists also work with [spread
+syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax).
+For instance, you can call a function like this.
+
+```js
+console.log(...list("hello", "there", "i'm", "logging", "elements"));
+```
+
+Then each element of the list will be passed as an argument to `console.log`.
+
+List also suports iterating backwards over lists through the
+[`backwards`](#backwards) function.
+
+### Iterator anti-patterns
+
+The iterable protocol allows for some very convenient patterns and
+means that lists can integrate nicely with JavaScript syntax. But,
+here are two anti-patterns that you should be aware of.
+
+1.  Don't overuse `for..of` loops. Functions like [`map`](#map) and
+    [`foldl`](#foldl) are often a better choice. If you want to perform
+    a side-effect for each element in a list you should probably use
+    [`forEach`](#forEach).
+2.  Don't use the spread syntax in destructuring
+    ```js
+    const [a, b, ...cs] = myList; // Don't do this
+    ```
+    The syntax converts the rest of the iterable (in this case a list)
+    into an array by iterating through the entire iterable. This is
+    slow and it turns our list into an array. This alternative avoids
+    both problems.
+    ```js
+    const [[a, b], cs] = splitAt(2, myList); // Do this
+    ```
+    This uses the [`splitAt`](#splitAt) function which splits and
+    creates the list `cs` very efficiently in `O(log(n))` time.
+
+## Seamless Ramda integration
+
+List is designed to work seamlessly together with Ramda. Ramda offers a large
+number of useful functions for working with arrays. List implements the same
+functions on its immutable data structure. This means that Ramda users can keep
+using the API they're familiar with. Additionally, List offers an entry point
+where all functions are curried.
+
+Since List implements Ramda's array API it is very easy to convert code from
+using arrays to using immutable lists. As an example, consider the code below.
+
+```js
+import * as R from "ramda";
+
+R.pipe(R.filter(n => n % 2 === 0), R.map(R.multiply(3)), R.reduce(R.add, 0))(
+  array
+);
+```
+
+The example can be converted to code using List as follows.
+
+```js
+import * as R from "ramda";
+import * as L from "list/curried";
+
+R.pipe(L.filter(n => n % 2 === 0), L.map(R.multiply(3)), L.reduce(R.add, 0))(
+  list
+);
+```
+
+For each function operating on arrays, the `R` is simply changed to an `L`.
+This works because List exports functions that have the same names and behavior
+as Ramdas functions.
+
+### Implemented Ramda functions
+
+The goal is to implement the entirety of Ramda's array functions for
+List. The list below keeps track of how many of Ramda functions that
+are missing and of how many that are already implemented. Currently 61
+out of 76 functions have been implemented.
+
+Implemented: `adjust`, `all`, `any`, `append`, `chain`, `concat`, `contains`,
+`drop`, `dropLast`, `dropRepeats`, `dropRepeatsWith`, `dropWhile`, `filter`,
+`find`, `findIndex`, `findLast`, `group`, `groupWith`, `head`, `flatten`,
+`indexOf`, `intersperse`, `init`, `insert`, `insertAll`, `last`, `lastIndexOf`,
+`length`, `join`, `map`, `none`, `nth`, `pair`, `partition`, `pluck`,
+`prepend`, `range`, `reduce`, `reduceRight`, `reduceWhile`, `reject`, `remove`,
+`reverse`, `repeat`, `scan`, `sequence`, `slice`, `sort`, `splitAt`,
+`splitEvery`, `splitWhen`, `take`, `takeWhile`, `tail`,
+`takeLast`,`takeLastWhile`, `traverse`, `times`, `update`, `zip`, `zipWith`.
+
+Not implemented: `aperture`, `dropLastWhile`, `endsWith`, `findLastIndex`,
+`indexBy`, `mapAccum`, `mapAccumRight`, `startsWith`, `transpose`, `unfold`,
+`uniq`, `uniqBy`, `uniqWith`, `unnest` `without`, `xprod`.
+
+### Differences compared to Ramda
+
+While List tries to stay as close to Ramda's API as possible there are a few
+deviations to be aware of.
+
+* List's curried functions do not support the `R.__` placeholder. Instead of
+  `R.reduce(R.__, 0, l)` one alternative is to use an arrow function `_ =>
+  L.reduce(_, 0, l)` instead.
+* [`sort`](#sort) and [`sortWith`](#sortwith) are different compared to what
+  they do in Ramda. `L.sortWith` is equivalent to `R.sort` and `L.sort` sorts a
+  list without taking a comparison function. This makes the common case of
+  sorting a list of numbers or strings easier
+
+## Fantasy Land & Static Land
+
+<img align="right" width="82" height="82" alt="Fantasy Land" src="https://raw.github.com/fantasyland/fantasy-land/master/logo.png">
+<img align="right" width="131" height="82" src="https://raw.githubusercontent.com/rpominov/static-land/master/logo/logo.png" />
+
+List currently implements the following Fantasy Land and Static Land
+specifications: Setoid, semigroup, monoid, foldable, functor, apply,
+applicative, chain, monad.
+
+The following specifications have not been implemented yet:
+Traversable, Ord.
+
+Since methods hinder tree-shaking the Fantasy Land methods are not
+included by default. In order to get them you must import it likes
+this:
+
+```js
+import "list/fantasy-land";
+```
+
+## API documentation
+
+The API is organized into three parts.
+
+1.  [Creating lists](#creating-lists) — Functions that _create_ lists.
+2.  [Updating lists](#updating-lists) — Functions that _transform_ lists.
+    That is, functions that take one or more lists as arguments and
+    returns a new list.
+3.  [Folds](#folds) — Functions that _extracts_ values based on lists.
+    They take one or more lists as arguments and returns something that
+    is not a list.
+
+### Creating lists
+
+### `list`
+
+Creates a list based on the arguments given.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+const l = list(1, 2, 3, 4); // creates a list of four elements
+const l2 = list("foo"); // creates a singleton
+```
+
+### `empty`
+
+Returns an empty list.
+
+**Complexity**: `O(1)`
+
+**Example**
+
+```js
+const emptyList = empty(); //=> list()
+```
+
+### `of`
+
+Takes a single arguments and returns a singleton list that contains it.
+
+**Complexity**: `O(1)`
+
+**Example**
+
+```js
+of("foo"); //=> list("foo")
+```
+
+### `pair`
+
+Takes two arguments and returns a list that contains them.
+
+**Complexity**: `O(1)`
+
+**Example**
+
+```js
+pair("foo", "bar"); //=> list("foo", "bar")
+```
+
+### `from`
+
+Converts an array, an array-like or an itearble into a list.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+from([0, 1, 2, 3, 4]); //=> list(0, 1, 2, 3, 4)
+```
+
+### `range`
+
+Returns a list of numbers between an inclusive lower bound and an
+exclusive upper bound.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+range(3, 8); //=> list(3, 4, 5, 6, 7)
+```
+
+### `repeat`
+
+Returns a list of a given length that contains the specified value in
+all positions.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+repeat(1, 7); //=> list(1, 1, 1, 1, 1, 1, 1)
+repeat("foo", 3); //=> list("foo", "foo", "foo")
+```
+
+### `times`
+
+Returns a list of given length that contains the value of the given function called with current index.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+const twoFirsOdds = times(i => i * 2 + 1, 2);
+const dots = times(() => {
+  const x = Math.random() * width;
+  const y = Math.random() * height;
+  return { x, y };
+}, 50);
+```
+
+### Updating lists
+
+### `concat`
+
+Concatenates two lists.
+
+**Complexity**: `O(log(n))`
+
+**Example**
+
+```js
+concat(list(0, 1, 2), list(3, 4)); //=> list(0, 1, 2, 3, 4)
+```
+
+### `flatten`
+
+Flattens a list of lists into a list. Note that this function does
+_not_ flatten recursively. It removes one level of nesting only.
+
+**Complexity**: `O(n * log(m))` where `n` is the length of the outer
+list and `m` the length of the inner lists.
+
+**Example**
+
+```js
+const nested = list(list(0, 1, 2, 3), list(4), empty(), list(5, 6));
+flatten(nested); //=> list(0, 1, 2, 3, 4, 5, 6)
+```
+
+### `prepend`
+
+Prepends an element to the front of a list and returns the new list.
+
+**Complexity**: `O(log(n))`, practically constant
+
+**Example**
+
+```js
+const newList = prepend(0, list(1, 2, 3)); //=> list(0, 1, 2, 3)
+```
+
+### `append`
+
+Appends an element to the end of a list and returns the new list.
+
+**Complexity**: `O(log(n))`, practically constant
+
+**Example**
+
+```js
+const newList = append(3, list(0, 1, 2)); //=> list(0, 1, 2, 3)
+```
+
+### `intersperse`
+
+Inserts a separator between each element in a list.
+
+**Example**
+
+```js
+intersperse("n", list("ba", "a", "a")); //=> list("ba", "n", "a", "n", "a")
+```
+
+### `map`
+
+Applies a function to each element in the given list and returns a new
+list of the values that the function return.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+map(n => n * n, list(0, 1, 2, 3, 4)); //=> list(0, 1, 4, 9, 16)
+```
+
+### `pluck`
+
+Extracts the specified property from each object in the list.
+
+**Example**
+
+```js
+const l = list(
+  { foo: 0, bar: "a" },
+  { foo: 1, bar: "b" },
+  { foo: 2, bar: "c" }
+);
+pluck("foo", l); //=> list(0, 1, 2)
+```
+
+### `update`
+
+Returns a list that has the entry specified by the index replaced with
+the given value.
+
+If the index is out of bounds the given list is
+returned unchanged.
+
+**Complexity**: `O(log(n))`
+
+**Example**
+
+```js
+update(2, "X", list("a", "b", "c", "d", "e")); //=> list("a", "b", "X", "d", "e")
+```
+
+### `adjust`
+
+Returns a list that has the entry specified by the index replaced with
+the value returned by applying the function to the value.
+
+If the index is out of bounds the given list is
+returned unchanged.
+
+**Complexity**: `O(log(n))`
+
+**Example**
+
+```js
+adjust(2, inc, list(0, 1, 2, 3, 4, 5)); //=> list(0, 1, 3, 3, 4, 5)
+```
+
+### `slice`
+
+Returns a slice of a list. Elements are removed from the beginning and
+end. Both the indices can be negative in which case they will count
+from the right end of the list.
+
+**Complexity**: `O(log(n))`
+
+**Example**
+
+```js
+const l = list(0, 1, 2, 3, 4, 5);
+slice(1, 4, l); //=> list(1, 2, 3)
+slice(2, -2, l); //=> list(2, 3)
+```
+
+### `take`
+
+Takes the first `n` elements from a list and returns them in a new list.
+
+**Complexity**: `O(log(n))`
+
+**Example**
+
+```js
+take(3, list(0, 1, 2, 3, 4, 5)); //=> list(0, 1, 2)
+```
+
+### `takeWhile`
+
+Takes the first elements in the list for which the predicate returns
+`true`.
+
+**Complexity**: `O(k + log(n))` where `k` is the number of elements
+satisfying the predicate.
+
+**Example**
+
+```js
+takeWhile(n => n < 4, list(0, 1, 2, 3, 4, 5, 6)); //=> list(0, 1, 2, 3)
+takeWhile(_ => false, list(0, 1, 2, 3, 4, 5)); //=> list()
+```
+
+### `takeLast`
+
+Takes the last `n` elements from a list and returns them in a new
+list.
+
+**Complexity**: `O(log(n))`
+
+**Example**
+
+```js
+takeLast(3, list(0, 1, 2, 3, 4, 5)); //=> list(3, 4, 5)
+```
+
+### `takeLastWhile`
+
+Takes the last elements in the list for which the predicate returns
+`true`.
+
+**Complexity**: `O(k + log(n))` where `k` is the number of elements
+satisfying the predicate.
+
+**Example**
+
+```js
+takeLastWhile(n => n > 2, list(0, 1, 2, 3, 4, 5)); //=> list(3, 4, 5)
+takeLastWhile(_ => false, list(0, 1, 2, 3, 4, 5)); //=> list()
+```
+
+### `splitAt`
+
+Splits a list at the given index and return the two sides in a pair.
+The left side will contain all elements before but not including the
+element at the given index. The right side contains the element at the
+index and all elements after it.
+
+**Complexity**: `O(log(n))`
+
+**Example**
+
+```js
+const l = list(0, 1, 2, 3, 4, 5, 6, 7, 8);
+splitAt(4, l); //=> [list(0, 1, 2, 3), list(4, 5, 6, 7, 8)]
+```
+
+### `splitWhen`
+
+Splits a list at the first element in the list for which the given
+predicate returns `true`.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+const l = list(0, 1, 2, 3, 4, 5, 6, 7);
+splitWhen((n) => n > 3, l); //=> [list(0, 1, 2, 3), list(4, 5, 6, 7)]
+```
+
+### `remove`
+
+Takes an index, a number of elements to remove and a list. Returns a
+new list with the given amount of elements removed from the specified
+index.
+
+**Complexity**: `O(log(n))`
+
+**Example**
+
+```js
+const l = list(0, 1, 2, 3, 4, 5, 6, 7, 8);
+remove(4, 3, l); //=> list(0, 1, 2, 3, 7, 8)
+remove(2, 5, l); //=> list(0, 1, 7, 8)
+```
+
+### `drop`
+
+Returns a new list without the first `n` elements.
+
+**Complexity**: `O(log(n))`
+
+**Example**
+
+```js
+drop(2, list(0, 1, 2, 3, 4, 5)); //=> list(2, 3, 4, 5)
+```
+
+### `dropWhile`
+
+Removes the first elements in the list for which the predicate returns
+`true`.
+
+**Complexity**: `O(k + log(n))` where `k` is the number of elements
+satisfying the predicate.
+
+**Example**
+
+```js
+dropWhile(n => n < 4, list(0, 1, 2, 3, 4, 5, 6)); //=> list(4, 5, 6)
+```
+
+### `dropLast`
+
+Returns a new list without the last `n` elements.
+
+**Complexity**: `O(log(n))`
+
+**Example**
+
+```js
+dropLast(2, list(0, 1, 2, 3, 4, 5)); //=> list(0, 1, 2, 3)
+```
+
+### `dropRepeats`
+
+Returns a new list without repeated elements.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+dropRepeats(L.list(0, 0, 1, 1, 1, 2, 3, 3, 4, 4)); //=> list(0, 1, 2, 3, 4)
+```
+
+### `dropRepeatsWith`
+
+Returns a new list without repeated elements by using the given
+function to determine when elements are equal.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+dropRepeatsWith(
+  (n, m) => Math.floor(n) === Math.floor(m),
+  list(0, 0.4, 1.2, 1.1, 1.8, 2.2, 3.8, 3.4, 4.7, 4.2)
+); //=> list(0, 1, 2, 3, 4)
+```
+
+### `tail`
+
+Returns a new list with the first element removed. If the list is
+empty the empty list is returne.
+
+**Complexity**: `O(1)`
+
+**Example**
+
+```js
+tail(list(0, 1, 2, 3)); //=> list(1, 2, 3)
+tail(empty()); //=> list()
+```
+
+### `pop`
+
+Returns a new list with the last element removed. If the list is empty
+the empty list is returned.
+
+**Aliases**: `init`
+
+**Complexity**: `O(1)`
+
+**Example**
+
+```js
+pop(list(0, 1, 2, 3)); //=> list(0, 1, 2)
+```
+
+### `filter`
+
+Returns a new list that only contains the elements of the original
+list for which the predicate returns `true`.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+filter(isEven, list(0, 1, 2, 3, 4, 5, 6)); //=> list(0, 2, 4, 6)
+```
+
+### `reject`
+
+Returns a new list that only contains the elements of the original
+list for which the predicate returns `false`.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+reject(isEven, list(0, 1, 2, 3, 4, 5, 6)); //=> list(1, 3, 5)
+```
+
+### `reverse`
+
+Reverses a list.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+reverse(list(0, 1, 2, 3, 4, 5)); //=> list(5, 4, 3, 2, 1, 0)
+```
+
+### `ap`
+
+Applies a list of functions to a list of values.
+
+**Example**
+
+```js
+ap(list((n: number) => n + 2, n => 2 * n, n => n * n), list(1, 2, 3)); //=> list(3, 4, 5, 2, 4, 6, 1, 4, 9)
+```
+
+### `chain`
+
+Maps a function over a list and concatenates all the resulting lists
+together.
+
+Also known as `flatMap`.
+
+**Example**
+
+```js
+chain(n => list(n, 2 * n, n * n), list(1, 2, 3)); //=> list(1, 2, 1, 2, 4, 4, 3, 6, 9)
+```
+
+### `partition`
+
+Splits the list into two lists. One list that contains all the values
+for which the predicate returns `true` and one containing the values for
+which it returns `false`.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+partition(isEven, list(0, 1, 2, 3, 4, 5)); //=> list(list(0, 2, 4), list(1, 3, 5))
+```
+
+### `insert`
+
+Inserts the given element at the given index in the list.
+
+**Complexity**: `O(log(n))`
+
+**Example**
+
+```js
+insert(2, "c", list("a", "b", "d", "e")); //=> list("a", "b", "c", "d", "e")
+```
+
+### `insertAll`
+
+Inserts the given list of elements at the given index in the list.
+
+**Complexity**: `O(log(n))`
+
+**Example**
+
+```js
+insertAll(2, list("c", "d"), list("a", "b", "e", "f")); //=> list("a", "b", "c", "d", "e", "f")
+```
+
+### `zipWith`
+
+This is like mapping over two lists at the same time. The two lists are
+iterated over in parallel and each pair of elements is passed to the function.
+The returned values are assembled into a new list.
+
+The shortest list determine the size of the result.
+
+**Complexity**: `O(log(n))` where `n` is the length of the smallest list.
+
+**Example**
+
+```js
+const names = list("Turing", "Curry");
+const years = list(1912, 1900);
+zipWith((name, year) => ({ name, year }), names, years);
+//=> list({ name: "Turing", year: 1912 }, { name: "Curry", year: 1900 });
+```
+
+### `zip`
+
+Iterate over two lists in parallel and collect the pairs.
+
+**Complexity**: `O(log(n))` where `n` is the length of the smallest list.
+
+**Example**
+
+```js
+const names = list("a", "b", "c", "d", "e");
+const years = list(0, 1, 2, 3, 4, 5, 6);
+//=> list(["a", 0], ["b", 1], ["c", 2], ["d", 3], ["e", 4]);
+```
+
+### `sort`
+
+Sorts the given list. The list should contain values that can be compared using
+the `<` operator or values that implement the Fantasy Land
+[Ord](https://github.com/fantasyland/fantasy-land#ord) specification.
+
+Performs a stable sort.
+
+**Complexity**: `O(n * log(n))`
+
+**Example**
+
+```js
+sort(list(5, 3, 1, 8, 2)); //=> list(1, 2, 3, 5, 8)
+sort(list("e", "a", "c", "b", "d"); //=> list("a", "b", "c", "d", "e")
+```
+
+### `sortBy`
+
+Sort the given list by passing each value through the function and comparing
+the resulting value. The function should either return values comparable using
+`<` or values that implement the Fantasy Land
+[Ord](https://github.com/fantasyland/fantasy-land#ord) specification.
+
+Performs a stable sort.
+
+**Complexity**: `O(n * log(n))`
+
+**Example**
+
+```js
+sortBy(
+  o => o.n,
+  list({ n: 4, m: "foo" }, { n: 3, m: "bar" }, { n: 1, m: "baz" })
+);
+//=> list({ n: 1, m: "baz" }, { n: 3, m: "bar" }, { n: 4, m: "foo" })
+
+sortBy(s => s.length, list("foo", "bar", "ba", "aa", "list", "z"));
+//=> list("z", "ba", "aa", "foo", "bar", "list")
+```
+
+### `sortWith`
+
+Sort the given list by comparing values using the given function. The function
+receieves two values and should return `-1` if the first value is stricty
+larger than the second, `0` is they are equal and `1` if the first values is
+strictly smaller than the second.
+
+Note that the comparison function is equivalent to the one required by
+[`Array.prototype.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort).
+
+Performs a stable sort.
+
+**Complexity**: `O(n * log(n))`
+
+**Example**
+
+```js
+sortWith((a, b) => {
+  if (a === b) {
+    return 0;
+  } else if (a < b) {
+    return -1;
+  } else {
+    return 1;
+  }
+}, list(5, 3, 1, 8, 2)); //=> list(1, 2, 3, 5, 8)
+```
+
+### `group`
+
+Returns a list of lists where each sublist's elements
+are all equal.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+group(list(0, 0, 1, 2, 2, 2, 3, 3)); //=> list(list(0, 0), list(1), list(2, 2, 2), list(3, 3))
+```
+
+### `groupWith`
+
+Returns a list of lists where each sublist's elements are pairwise
+equal based on the given comparison function.
+
+Note that only adjacent elements are compared for equality. If all
+equal elements should be grouped together the list should be sorted
+before grouping.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+const floorEqual = (a, b) => Math.round(a) === Math.round(b);
+groupWith(floorEqual, list(1.1, 1.3, 1.8, 2, 2.2, 3.3, 3.4));
+//=> list(list(1.1, 1.3), list(1.8, 2, 2.2), list(3.3, 3.4))
+
+const sameLength = (a, b) => a.length === b.length;
+groupWith(sameLength, list("foo", "bar", "ab", "bc", "baz"));
+//=> list(list("foo", "bar"), list("ab", "bc"), list("baz))
+```
+
+### Folds
+
+### `isList`
+
+Returns `true` if the given argument is a list.
+
+**Complexity**: `O(1)`
+
+**Example**
+
+```js
+isList([0, 1, 2]); //=> false
+isList("string"); //=> false
+isList({ foo: 0, bar: 1 }); //=> false
+isList(list(0, 1, 2)); //=> true
+```
+
+### `equals`
+
+Returns true if the two lists are equivalent.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+equals(list(0, 1, 2, 3), list(0, 1, 2, 3)); //=> true
+equals(list("a", "b", "c"), list("a", "z", "c")); //=> false
+```
+
+### `equalsWith`
+
+Returns `true` if the two lists are equivalent when comparing each
+pair of elements with the given comparison function.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+equalsWith(
+  (n, m) => n.length === m.length,
+  list("foo", "hello", "one"),
+  list("bar", "world", "two")
+); //=> true
+```
+
+### `toArray`
+
+Converts a list into an array.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+toArray(list(0, 1, 2, 3, 4)); //=> [0, 1, 2, 3, 4]
+```
+
+### `backwards`
+
+Returns an iterable that iterates backwards over the given list.
+
+**Complexity**: `O(1)`
+
+**Example**
+
+```js
+const l = list(0, 1, 2, 3, 4)
+for (const n of backwards(l)) {
+  if (l < 2) {
+    break;
+  }
+  console.log(l);
+}
+// => logs 4, 3, and then 2
+```
+
+### `nth`
+
+Gets the `n`th element of the list. If `n` is out of bounds
+`undefined` is returned.
+
+**Complexity**: `O(log(n))`, practically constant
+
+**Example**
+
+```js
+const l = list(0, 1, 2, 3, 4);
+nth(2, l); //=> 2
+```
+
+### `length`
+
+Returns the length of a list. I.e. the number of elements that it
+contains.
+
+**Complexity**: `O(1)`
+
+**Example**
+
+```js
+length(list(0, 1, 2, 3)); //=> 4
+```
+
+### `first`
+
+Returns the first element of the list. If the list is empty the
+function returns `undefined`.
+
+**Aliases**: `head`
+
+**Complexity**: `O(1)`
+
+**Example**
+
+```js
+first(list(0, 1, 2, 3)); //=> 0
+first(list()); //=> undefined
+```
+
+### `last`
+
+Returns the last element of the list. If the list is empty the
+function returns `undefined`.
+
+**Complexity**: `O(1)`
+
+**Example**
+
+```js
+last(list(0, 1, 2, 3)); //=> 3
+last(list()); //=> undefined
+```
+
+### `foldl`
+
+Folds a function over a list. Left-associative.
+
+**Aliases**: `reduce`
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+foldl((n, m) => n - m, 1, list(2, 3, 4, 5));
+1 - 2 - 3 - 4 - 5; //=> -13
+```
+
+### `foldr`
+
+Folds a function over a list. Right-associative.
+
+**Aliases**: `reduceRight`
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+foldr((n, m) => n - m, 5, list(1, 2, 3, 4));
+1 - (2 - (3 - (4 - 5))); //=> 3
+```
+
+### `foldlWhile`
+
+Similar to `foldl`. But, for each element it calls the predicate function
+_before_ the folding function and stops folding if it returns `false`.
+
+**Aliases**: `reduceWhile`
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+const isOdd = (_acc:, x) => x % 2 === 1;
+
+const xs = L.list(1, 3, 5, 60, 777, 800);
+foldlWhile(isOdd, (n, m) => n + m, 0, xs) //=> 9
+
+const ys = L.list(2, 4, 6);
+foldlWhile(isOdd, (n, m) => n + m, 111, ys) //=> 111
+```
+
+### `scan`
+
+Folds a function over a list from left to right while collecting all the
+intermediate steps in a resulting list.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+const l = list(1, 3, 5, 4, 2);
+L.scan((n, m) => n + m, 0, l); //=> list(0, 1, 4, 9, 13, 15));
+L.scan((s, m) => s + m.toString(), "", l); //=> list("", "1", "13", "135", "1354", "13542")
+```
+
+### `traverse`
+
+Map each element of list to an applicative, evaluate these
+applicatives from left to right, and collect the results.
+
+This works with Fantasy Land
+[applicatives](https://github.com/fantasyland/fantasy-land#applicative).
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+const safeDiv = n => d => d === 0 ? nothing : just(n / d)
+
+L.traverse(Maybe, safeDiv(10), list(2, 4, 5)); //=> just(list(5, 2.5, 2))
+L.traverse(Maybe, safeDiv(10), list(2, 0, 5)); //=> nothing
+```
+
+### `sequence`
+
+Evaluate each applicative in the list from left to right, and
+collect the results.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+L.sequence(Maybe, list(just(1), just(2), just(3))); //=> just(list(1, 2, 3))
+L.sequence(Maybe, list(just(1), just(2), nothing())); //=> nothing
+```
+
+### `forEach`
+
+Invokes a given callback for each element in the list from left to
+right. Returns `undefined`.
+
+This function is very similar to `map`. It should be used instead of
+`map` when the mapping function has side-effects. Whereas `map`
+constructs a new list `forEach` merely returns `undefined`. This makes
+`forEach` faster when the new list is unneeded.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+const l = list(0, 1, 2);
+forEach(element => console.log(element));
+//=> 0
+//=> 1
+//=> 2
+```
+
+### `every`
+
+Returns `true` if and only if the predicate function returns `true`
+for all elements in the given list.
+
+**Aliases**: `all`
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+const isEven = n => n % 2 === 0;
+every(isEven, empty()); //=> true
+every(isEven, list(2, 4, 6, 8)); //=> true
+every(isEven, list(2, 3, 4, 6, 7, 8)); //=> false
+every(isEven, list(1, 3, 5, 7)); //=> false
+```
+
+### `some`
+
+Returns `true` if and only if there exists an element in the list for
+which the predicate returns `true`.
+
+**Aliases**: `any`
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+const isEven = n => n % 2 === 0;
+some(isEven, empty()); //=> false
+some(isEven, list(2, 4, 6, 8)); //=> true
+some(isEven, list(2, 3, 4, 6, 7, 8)); //=> true
+some(isEven, list(1, 3, 5, 7)); //=> false
+```
+
+### `indexOf`
+
+Returns the index of the _first_ element in the list that is equal to
+the given element. If no such element is found `-1` is returned.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+const l = list(12, 4, 2, 89, 6, 18, 7);
+indexOf(12, l); //=> 0
+indexOf(89, l); //=> 3
+indexOf(10, l); //=> -1
+```
+
+### `lastIndexOf`
+
+Returns the index of the _last_ element in the list that is equal to
+the given element. If no such element is found `-1` is returned.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+const l = L.list(12, 4, 2, 18, 89, 2, 18, 7);
+L.lastIndexOf(18, l); //=> 6
+L.lastIndexOf(2, l); //=> 5
+L.lastIndexOf(12, l); //=> 0
+```
+
+### `find`
+
+Returns the _first_ element for which the predicate returns `true`. If
+no such element is found the function returns `undefined`.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+find(isEven, list(1, 3, 5, 6, 7, 9, 10)); //=> 6
+find(isEven, list(1, 3, 5, 7, 9)); //=> undefined
+```
+
+### `findLast`
+
+Returns the _last_ element for which the predicate returns `true`. If
+no such element is found the function returns `undefined`.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+findLast(isEven, list(1, 3, 5, 6, 7, 8, 9)); //=> 8
+findLast(isEven, list(1, 3, 5, 7, 9)); //=> undefined
+```
+
+### `findIndex`
+
+Returns the index of the first element for which the predicate returns
+`true`. If no such element is found the function returns `-1`.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+findIndex(isEven, list(1, 3, 5, 6, 7, 9, 10)); //=> 3
+findIndex(isEven, list(1, 3, 5, 7, 9)); //=> -1
+```
+
+### `none`
+
+Returns `true` if and only if the predicate function returns `false`
+for all elements in the given list.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+const isEven = n => n % 2 === 0;
+none(isEven, empty()); //=> true
+none(isEven, list(2, 4, 6, 8)); //=> false
+none(isEven, list(2, 3, 4, 6, 7, 8)); //=> false
+none(isEven, list(1, 3, 5, 7)); //=> true
+```
+
+### `includes`
+
+Returns `true` if the list contains the specified element. Otherwise
+it returns `false`.
+
+**Aliases**: `contains`
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+includes(3, list(0, 1, 2, 3, 4, 5)); //=> true
+includes(3, list(0, 1, 2, 4, 5)); //=> false
+```
+
+### `join`
+
+Concats the strings in a list separated by a specified separator.
+
+**Complexity**: `O(n)`
+
+**Example**
+
+```js
+join(", ", list("one", "two", "three")); //=> "one, two, three"
+```
+
+## Benchmarks
+
+The benchmarks are located in the [`bench` directory](/test/bench).
diff --git a/node_modules/list/curried/package.json b/node_modules/list/curried/package.json
new file mode 100644
index 0000000..e7ece72
--- /dev/null
+++ b/node_modules/list/curried/package.json
@@ -0,0 +1,7 @@
+{
+  "name": "list/curried",
+  "private": true,
+  "main": "../dist/curried.js",
+  "module": "../dist/es/curried.js",
+  "types": "../dist/curried.d.ts"
+}
diff --git a/node_modules/list/dist/curried.d.ts b/node_modules/list/dist/curried.d.ts
new file mode 100644
index 0000000..9155efd
--- /dev/null
+++ b/node_modules/list/dist/curried.d.ts
@@ -0,0 +1,110 @@
+import * as L from "./index";
+import { List } from "./index";
+export { Node, List, list, isList, length, of, empty, first, head, last, flatten, pop, init, tail, from, toArray, reverse, backwards, sort, group, dropRepeats, isEmpty } from "./index";
+export interface Curried2<A, B, R> {
+    (a: A): (b: B) => R;
+    (a: A, b: B): R;
+}
+export interface Curried3<A, B, C, R> {
+    (a: A, b: B, c: C): R;
+    (a: A, b: B): (c: C) => R;
+    (a: A): Curried2<B, C, R>;
+}
+export declare const prepend: typeof L.prepend & (<A>(value: A) => (l: List<A>) => List<A>);
+export declare const append: typeof prepend;
+export declare const pair: typeof L.pair & (<A>(first: A) => (second: A) => List<A>);
+export declare const repeat: typeof L.repeat & (<A>(value: A) => (times: number) => List<A>);
+export declare const times: typeof L.times & (<A>(func: (index: number) => A) => (times: number) => List<A>);
+export declare const nth: typeof L.nth & ((index: number) => <A>(l: List<A>) => A | undefined);
+export declare const map: typeof L.map & (<A, B>(f: (a: A) => B) => (l: List<A>) => List<B>);
+export declare const forEach: typeof L.forEach & (<A>(callback: (a: A) => void) => (l: List<A>) => void);
+export declare const pluck: typeof L.pluck & (<K extends string>(key: K) => <C, B extends K & (keyof C)>(l: List<C>) => List<C[B]>);
+export declare const intersperse: typeof prepend;
+export declare const range: typeof L.range & ((start: number) => (end: number) => List<number>);
+export declare const filter: typeof L.filter & (<A, B extends A>(predicate: (a: A) => a is B) => (l: List<A>) => List<B>) & (<A>(predicate: (a: A) => boolean) => (l: List<A>) => List<A>);
+export declare const reject: typeof filter;
+export declare const partition: typeof L.partition & (<A>(predicate: (a: A) => boolean) => (l: List<A>) => [List<A>, List<A>]);
+export declare const join: typeof L.join & ((seperator: string) => (l: List<string>) => List<string>);
+export declare const ap: typeof L.ap & (<A, B>(listF: List<(a: A) => B>) => (l: List<A>) => List<B>);
+export declare const flatMap: typeof L.flatMap & (<A, B>(f: (a: A) => List<B>) => (l: List<A>) => List<B>);
+export declare const chain: typeof L.flatMap & (<A, B>(f: (a: A) => L.List<B>) => (l: L.List<A>) => L.List<B>);
+export declare const every: typeof L.every & (<A>(predicate: (a: A) => boolean) => (l: List<A>) => boolean);
+export declare const all: typeof every;
+export declare const some: typeof every;
+export declare const any: typeof every;
+export declare const none: typeof every;
+export declare const find: typeof L.find & (<A>(predicate: (a: A) => boolean) => (l: List<A>) => A | undefined);
+export declare const findLast: typeof find;
+export declare const indexOf: typeof L.indexOf & (<A>(element: A) => (l: List<A>) => number);
+export declare const lastIndexOf: typeof indexOf;
+export declare const findIndex: typeof L.findIndex & (<A>(predicate: (a: A) => boolean) => (l: List<A>) => number);
+export declare const includes: typeof L.includes & (<A>(element: A) => (l: List<A>) => number);
+export declare const contains: typeof L.includes & (<A>(element: A) => (l: L.List<A>) => number);
+export declare const equals: typeof L.equals & (<A>(first: List<A>) => (second: List<A>) => boolean);
+export declare const concat: typeof L.concat & (<A>(left: List<A>) => (right: List<A>) => List<A>);
+export declare const take: typeof L.take & ((n: number) => <A>(l: List<A>) => List<A>);
+export declare const takeLast: typeof take;
+export declare const drop: typeof take;
+export declare const dropRepeatsWith: typeof L.dropRepeatsWith & (<A>(f: (a: A, b: A) => boolean) => (l: List<A>) => List<A>);
+export declare const dropLast: typeof take;
+export declare const takeWhile: typeof filter;
+export declare const takeLastWhile: typeof filter;
+export declare const dropWhile: typeof filter;
+export declare const splitAt: typeof L.splitAt & ((index: number) => <A>(l: List<A>) => [List<A>, List<A>]);
+export declare const splitWhen: typeof L.splitWhen & (<A>(predicate: (a: A) => boolean) => (l: List<A>) => [List<A>, List<A>]);
+export declare const splitEvery: typeof L.splitEvery & (<A>(size: number) => (l: List<A>) => List<List<A>>);
+export declare const sortBy: typeof L.sortBy & (<A, B extends L.Comparable>(f: (a: A) => B) => (l: List<A>) => List<A>);
+export declare const sortWith: typeof L.sortWith & (<A>(comparator: (a: A, b: A) => L.Ordering) => (l: List<A>) => List<A>);
+export declare const groupWith: typeof L.groupWith & (<A>(f: (a: A, b: A) => boolean) => (l: List<A>) => List<List<A>>);
+export declare const zip: typeof L.zip & (<A>(as: List<A>) => <B>(bs: List<B>) => List<[A, B]>);
+export declare const sequence: typeof L.sequence & ((ofObj: L.Of) => <A>(l: List<L.Applicative<A>>) => any);
+export declare const foldl: typeof L.foldl & {
+    <A, B>(f: (acc: B, value: A) => B): Curried2<B, List<A>, B>;
+    <A, B>(f: (acc: B, value: A) => B, initial: B): (l: List<A>) => B;
+};
+export declare const reduce: typeof foldl;
+export declare const scan: typeof L.scan & {
+    <A, B>(f: (acc: B, value: A) => B): Curried2<B, List<A>, List<B>>;
+    <A, B>(f: (acc: B, value: A) => B, initial: B): (l: List<A>) => List<B>;
+};
+export declare const foldr: typeof L.foldl & {
+    <A, B>(f: (value: A, acc: B) => B): Curried2<B, List<A>, B>;
+    <A, B>(f: (value: A, acc: B) => B, initial: B): (l: List<A>) => B;
+};
+export declare const traverse: typeof L.traverse & {
+    (of: L.Of): (<A, B>(f: (a: A) => L.Applicative<B>) => (l: List<B>) => any) & (<A, B>(f: (a: A) => L.Applicative<B>, l: List<B>) => any);
+    <A, B>(of: L.Of, f: (a: A) => L.Applicative<B>): (l: List<B>) => any;
+};
+export declare const equalsWith: typeof L.equalsWith & {
+    <A>(f: (a: A, b: A) => boolean): Curried2<List<A>, List<A>, boolean>;
+    <A>(f: (a: A, b: A) => boolean, l1: List<A>): (l2: List<A>) => boolean;
+};
+export declare const reduceRight: typeof foldr;
+export declare const update: typeof L.update & {
+    <A>(index: number, a: A): (l: List<A>) => List<A>;
+    <A>(index: number): ((a: A, l: List<A>) => List<A>) & ((a: A) => (l: List<A>) => List<A>);
+};
+export declare const adjust: typeof L.adjust & {
+    <A>(index: number, f: (value: A) => A): (l: List<A>) => List<A>;
+    (index: number): <A>(f: (value: A) => A, l: List<A>) => List<A> & (<A>(f: (value: A) => A) => (l: List<A>) => List<A>);
+};
+export declare const slice: typeof L.slice & {
+    (from: number): (<A>(to: number) => (l: List<A>) => List<A>) & (<A>(to: number, l: List<A>) => List<A>);
+    (from: number, to: number): <A>(l: List<A>) => List<A>;
+};
+export declare const remove: typeof slice;
+export declare const insert: typeof update;
+export declare const insertAll: typeof L.insertAll & {
+    <A>(index: number, elements: List<A>): (l: List<A>) => List<A>;
+    <A>(index: number): ((elements: List<A>, l: List<A>) => List<A>) & ((elements: List<A>) => (l: List<A>) => List<A>);
+};
+export declare const zipWith: typeof L.zipWith & {
+    <A, B, C>(f: (a: A, b: B) => C, as: List<A>): (bs: List<B>) => List<C>;
+    <A, B, C>(f: (a: A, b: B) => C): Curried2<List<A>, List<B>, List<C>>;
+};
+export declare const foldlWhile: typeof L.foldlWhile & {
+    <A, B>(predicate: (acc: B, value: A) => boolean, f: (acc: B, value: A) => B, initial: B): (l: List<A>) => B;
+    <A, B>(predicate: (acc: B, value: A) => boolean, f: (acc: B, value: A) => B): Curried2<B, List<A>, B>;
+    <A, B>(predicate: (acc: B, value: A) => boolean): Curried3<(acc: B, value: A) => B, B, List<A>, B>;
+};
+export declare const reduceWhile: typeof foldlWhile;
diff --git a/node_modules/list/dist/curried.js b/node_modules/list/dist/curried.js
new file mode 100644
index 0000000..1785c44
--- /dev/null
+++ b/node_modules/list/dist/curried.js
@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var L = require("./index");
+var index_1 = require("./index");
+exports.Node = index_1.Node;
+exports.List = index_1.List;
+exports.list = index_1.list;
+exports.isList = index_1.isList;
+exports.length = index_1.length;
+exports.of = index_1.of;
+exports.empty = index_1.empty;
+exports.first = index_1.first;
+exports.head = index_1.head;
+exports.last = index_1.last;
+exports.flatten = index_1.flatten;
+exports.pop = index_1.pop;
+exports.init = index_1.init;
+exports.tail = index_1.tail;
+exports.from = index_1.from;
+exports.toArray = index_1.toArray;
+exports.reverse = index_1.reverse;
+exports.backwards = index_1.backwards;
+exports.sort = index_1.sort;
+exports.group = index_1.group;
+exports.dropRepeats = index_1.dropRepeats;
+exports.isEmpty = index_1.isEmpty;
+function curry2(f) {
+    return function curried(a, b) {
+        return arguments.length === 2 ? f(a, b) : function (b) { return f(a, b); };
+    };
+}
+function curry3(f) {
+    return function curried(a, b, c) {
+        switch (arguments.length) {
+            case 3:
+                return f(a, b, c);
+            case 2:
+                return function (c) { return f(a, b, c); };
+            default:
+                return curry2(function (b, c) { return f(a, b, c); });
+        }
+    };
+}
+function curry4(f) {
+    return function curried(a, b, c, d) {
+        switch (arguments.length) {
+            case 4:
+                return f(a, b, c, d);
+            case 3:
+                return function (d) { return f(a, b, c, d); };
+            case 2:
+                return curry2(function (c, d) { return f(a, b, c, d); });
+            default:
+                return curry3(function (b, c, d) { return f(a, b, c, d); });
+        }
+    };
+}
+exports.prepend = curry2(L.prepend);
+exports.append = curry2(L.append);
+exports.pair = curry2(L.pair);
+exports.repeat = curry2(L.repeat);
+exports.times = curry2(L.times);
+exports.nth = curry2(L.nth);
+exports.map = curry2(L.map);
+exports.forEach = curry2(L.forEach);
+exports.pluck = curry2(L.pluck);
+exports.intersperse = curry2(L.intersperse);
+exports.range = curry2(L.range);
+exports.filter = curry2(L.filter);
+exports.reject = curry2(L.reject);
+exports.partition = curry2(L.partition);
+exports.join = curry2(L.join);
+exports.ap = curry2(L.ap);
+exports.flatMap = curry2(L.flatMap);
+exports.chain = exports.flatMap;
+exports.every = curry2(L.every);
+exports.all = curry2(L.all);
+exports.some = curry2(L.some);
+exports.any = curry2(L.any);
+exports.none = curry2(L.none);
+exports.find = curry2(L.find);
+exports.findLast = curry2(L.findLast);
+exports.indexOf = curry2(L.indexOf);
+exports.lastIndexOf = curry2(L.lastIndexOf);
+exports.findIndex = curry2(L.findIndex);
+exports.includes = curry2(L.includes);
+exports.contains = exports.includes;
+exports.equals = curry2(L.equals);
+exports.concat = curry2(L.concat);
+exports.take = curry2(L.take);
+exports.takeLast = curry2(L.takeLast);
+exports.drop = curry2(L.drop);
+exports.dropRepeatsWith = curry2(L.groupWith);
+exports.dropLast = curry2(L.dropLast);
+exports.takeWhile = curry2(L.takeWhile);
+exports.takeLastWhile = curry2(L.takeLastWhile);
+exports.dropWhile = curry2(L.dropWhile);
+exports.splitAt = curry2(L.splitAt);
+exports.splitWhen = curry2(L.splitWhen);
+exports.splitEvery = curry2(L.splitEvery);
+exports.sortBy = curry2(L.sortBy);
+exports.sortWith = curry2(L.sortWith);
+exports.groupWith = curry2(L.groupWith);
+exports.zip = curry2(L.zip);
+exports.sequence = curry2(L.sequence);
+exports.foldl = curry3(L.foldl);
+exports.reduce = exports.foldl;
+exports.scan = curry3(L.scan);
+exports.foldr = curry3(L.foldr);
+exports.traverse = curry3(L.traverse);
+exports.equalsWith = curry3(L.equalsWith);
+exports.reduceRight = exports.foldr;
+exports.update = curry3(L.update);
+exports.adjust = curry3(L.adjust);
+exports.slice = curry3(L.slice);
+exports.remove = curry3(L.remove);
+exports.insert = curry3(L.insert);
+exports.insertAll = curry3(L.insertAll);
+exports.zipWith = curry3(L.zipWith);
+exports.foldlWhile = curry4(L.foldlWhile);
+exports.reduceWhile = exports.foldlWhile;
diff --git a/node_modules/list/dist/devtools.d.ts b/node_modules/list/dist/devtools.d.ts
new file mode 100644
index 0000000..cb0ff5c
--- /dev/null
+++ b/node_modules/list/dist/devtools.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/list/dist/devtools.js b/node_modules/list/dist/devtools.js
new file mode 100644
index 0000000..8e20dc3
--- /dev/null
+++ b/node_modules/list/dist/devtools.js
@@ -0,0 +1,46 @@
+"use strict";
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var L = require("./index");
+var listStyle = {
+    style: "list-style-type: none; padding: 0; margin: 0 0 0 22px; font-style: normal"
+};
+var gw = typeof window === undefined ? global : window;
+if (gw.devtoolsFormatters === undefined) {
+    gw.devtoolsFormatters = [];
+}
+function createReference(object) {
+    return ["object", { object: object }];
+}
+var l = L.list("hello", "world");
+L.intersperse(", ", l);
+gw.devtoolsFormatters.push({
+    header: function (l) {
+        if (L.isList(l)) {
+            return __spreadArrays([
+                "div",
+                { style: "font-style: italic" },
+                ["span", {}, "(" + l.length + ") list("]
+            ], L.toArray(L.intersperse(", ", L.map(createReference, l))), [
+                ["span", {}, ")"]
+            ]);
+        }
+        else {
+            return null;
+        }
+    },
+    hasBody: function (l) {
+        return l.length !== 0;
+    },
+    body: function (l) {
+        var idx = 0;
+        var children = L.map(function (o) { return ["li", ["span", {}, idx++ + ": "], createReference(o)]; }, l);
+        return __spreadArrays(["ol", listStyle], L.toArray(children));
+    }
+});
diff --git a/node_modules/list/dist/es/curried.d.ts b/node_modules/list/dist/es/curried.d.ts
new file mode 100644
index 0000000..9155efd
--- /dev/null
+++ b/node_modules/list/dist/es/curried.d.ts
@@ -0,0 +1,110 @@
+import * as L from "./index";
+import { List } from "./index";
+export { Node, List, list, isList, length, of, empty, first, head, last, flatten, pop, init, tail, from, toArray, reverse, backwards, sort, group, dropRepeats, isEmpty } from "./index";
+export interface Curried2<A, B, R> {
+    (a: A): (b: B) => R;
+    (a: A, b: B): R;
+}
+export interface Curried3<A, B, C, R> {
+    (a: A, b: B, c: C): R;
+    (a: A, b: B): (c: C) => R;
+    (a: A): Curried2<B, C, R>;
+}
+export declare const prepend: typeof L.prepend & (<A>(value: A) => (l: List<A>) => List<A>);
+export declare const append: typeof prepend;
+export declare const pair: typeof L.pair & (<A>(first: A) => (second: A) => List<A>);
+export declare const repeat: typeof L.repeat & (<A>(value: A) => (times: number) => List<A>);
+export declare const times: typeof L.times & (<A>(func: (index: number) => A) => (times: number) => List<A>);
+export declare const nth: typeof L.nth & ((index: number) => <A>(l: List<A>) => A | undefined);
+export declare const map: typeof L.map & (<A, B>(f: (a: A) => B) => (l: List<A>) => List<B>);
+export declare const forEach: typeof L.forEach & (<A>(callback: (a: A) => void) => (l: List<A>) => void);
+export declare const pluck: typeof L.pluck & (<K extends string>(key: K) => <C, B extends K & (keyof C)>(l: List<C>) => List<C[B]>);
+export declare const intersperse: typeof prepend;
+export declare const range: typeof L.range & ((start: number) => (end: number) => List<number>);
+export declare const filter: typeof L.filter & (<A, B extends A>(predicate: (a: A) => a is B) => (l: List<A>) => List<B>) & (<A>(predicate: (a: A) => boolean) => (l: List<A>) => List<A>);
+export declare const reject: typeof filter;
+export declare const partition: typeof L.partition & (<A>(predicate: (a: A) => boolean) => (l: List<A>) => [List<A>, List<A>]);
+export declare const join: typeof L.join & ((seperator: string) => (l: List<string>) => List<string>);
+export declare const ap: typeof L.ap & (<A, B>(listF: List<(a: A) => B>) => (l: List<A>) => List<B>);
+export declare const flatMap: typeof L.flatMap & (<A, B>(f: (a: A) => List<B>) => (l: List<A>) => List<B>);
+export declare const chain: typeof L.flatMap & (<A, B>(f: (a: A) => L.List<B>) => (l: L.List<A>) => L.List<B>);
+export declare const every: typeof L.every & (<A>(predicate: (a: A) => boolean) => (l: List<A>) => boolean);
+export declare const all: typeof every;
+export declare const some: typeof every;
+export declare const any: typeof every;
+export declare const none: typeof every;
+export declare const find: typeof L.find & (<A>(predicate: (a: A) => boolean) => (l: List<A>) => A | undefined);
+export declare const findLast: typeof find;
+export declare const indexOf: typeof L.indexOf & (<A>(element: A) => (l: List<A>) => number);
+export declare const lastIndexOf: typeof indexOf;
+export declare const findIndex: typeof L.findIndex & (<A>(predicate: (a: A) => boolean) => (l: List<A>) => number);
+export declare const includes: typeof L.includes & (<A>(element: A) => (l: List<A>) => number);
+export declare const contains: typeof L.includes & (<A>(element: A) => (l: L.List<A>) => number);
+export declare const equals: typeof L.equals & (<A>(first: List<A>) => (second: List<A>) => boolean);
+export declare const concat: typeof L.concat & (<A>(left: List<A>) => (right: List<A>) => List<A>);
+export declare const take: typeof L.take & ((n: number) => <A>(l: List<A>) => List<A>);
+export declare const takeLast: typeof take;
+export declare const drop: typeof take;
+export declare const dropRepeatsWith: typeof L.dropRepeatsWith & (<A>(f: (a: A, b: A) => boolean) => (l: List<A>) => List<A>);
+export declare const dropLast: typeof take;
+export declare const takeWhile: typeof filter;
+export declare const takeLastWhile: typeof filter;
+export declare const dropWhile: typeof filter;
+export declare const splitAt: typeof L.splitAt & ((index: number) => <A>(l: List<A>) => [List<A>, List<A>]);
+export declare const splitWhen: typeof L.splitWhen & (<A>(predicate: (a: A) => boolean) => (l: List<A>) => [List<A>, List<A>]);
+export declare const splitEvery: typeof L.splitEvery & (<A>(size: number) => (l: List<A>) => List<List<A>>);
+export declare const sortBy: typeof L.sortBy & (<A, B extends L.Comparable>(f: (a: A) => B) => (l: List<A>) => List<A>);
+export declare const sortWith: typeof L.sortWith & (<A>(comparator: (a: A, b: A) => L.Ordering) => (l: List<A>) => List<A>);
+export declare const groupWith: typeof L.groupWith & (<A>(f: (a: A, b: A) => boolean) => (l: List<A>) => List<List<A>>);
+export declare const zip: typeof L.zip & (<A>(as: List<A>) => <B>(bs: List<B>) => List<[A, B]>);
+export declare const sequence: typeof L.sequence & ((ofObj: L.Of) => <A>(l: List<L.Applicative<A>>) => any);
+export declare const foldl: typeof L.foldl & {
+    <A, B>(f: (acc: B, value: A) => B): Curried2<B, List<A>, B>;
+    <A, B>(f: (acc: B, value: A) => B, initial: B): (l: List<A>) => B;
+};
+export declare const reduce: typeof foldl;
+export declare const scan: typeof L.scan & {
+    <A, B>(f: (acc: B, value: A) => B): Curried2<B, List<A>, List<B>>;
+    <A, B>(f: (acc: B, value: A) => B, initial: B): (l: List<A>) => List<B>;
+};
+export declare const foldr: typeof L.foldl & {
+    <A, B>(f: (value: A, acc: B) => B): Curried2<B, List<A>, B>;
+    <A, B>(f: (value: A, acc: B) => B, initial: B): (l: List<A>) => B;
+};
+export declare const traverse: typeof L.traverse & {
+    (of: L.Of): (<A, B>(f: (a: A) => L.Applicative<B>) => (l: List<B>) => any) & (<A, B>(f: (a: A) => L.Applicative<B>, l: List<B>) => any);
+    <A, B>(of: L.Of, f: (a: A) => L.Applicative<B>): (l: List<B>) => any;
+};
+export declare const equalsWith: typeof L.equalsWith & {
+    <A>(f: (a: A, b: A) => boolean): Curried2<List<A>, List<A>, boolean>;
+    <A>(f: (a: A, b: A) => boolean, l1: List<A>): (l2: List<A>) => boolean;
+};
+export declare const reduceRight: typeof foldr;
+export declare const update: typeof L.update & {
+    <A>(index: number, a: A): (l: List<A>) => List<A>;
+    <A>(index: number): ((a: A, l: List<A>) => List<A>) & ((a: A) => (l: List<A>) => List<A>);
+};
+export declare const adjust: typeof L.adjust & {
+    <A>(index: number, f: (value: A) => A): (l: List<A>) => List<A>;
+    (index: number): <A>(f: (value: A) => A, l: List<A>) => List<A> & (<A>(f: (value: A) => A) => (l: List<A>) => List<A>);
+};
+export declare const slice: typeof L.slice & {
+    (from: number): (<A>(to: number) => (l: List<A>) => List<A>) & (<A>(to: number, l: List<A>) => List<A>);
+    (from: number, to: number): <A>(l: List<A>) => List<A>;
+};
+export declare const remove: typeof slice;
+export declare const insert: typeof update;
+export declare const insertAll: typeof L.insertAll & {
+    <A>(index: number, elements: List<A>): (l: List<A>) => List<A>;
+    <A>(index: number): ((elements: List<A>, l: List<A>) => List<A>) & ((elements: List<A>) => (l: List<A>) => List<A>);
+};
+export declare const zipWith: typeof L.zipWith & {
+    <A, B, C>(f: (a: A, b: B) => C, as: List<A>): (bs: List<B>) => List<C>;
+    <A, B, C>(f: (a: A, b: B) => C): Curried2<List<A>, List<B>, List<C>>;
+};
+export declare const foldlWhile: typeof L.foldlWhile & {
+    <A, B>(predicate: (acc: B, value: A) => boolean, f: (acc: B, value: A) => B, initial: B): (l: List<A>) => B;
+    <A, B>(predicate: (acc: B, value: A) => boolean, f: (acc: B, value: A) => B): Curried2<B, List<A>, B>;
+    <A, B>(predicate: (acc: B, value: A) => boolean): Curried3<(acc: B, value: A) => B, B, List<A>, B>;
+};
+export declare const reduceWhile: typeof foldlWhile;
diff --git a/node_modules/list/dist/es/curried.js b/node_modules/list/dist/es/curried.js
new file mode 100644
index 0000000..8ea8538
--- /dev/null
+++ b/node_modules/list/dist/es/curried.js
@@ -0,0 +1,97 @@
+import * as L from "./index";
+export { Node, List, list, isList, length, of, empty, first, head, last, flatten, pop, init, tail, from, toArray, reverse, backwards, sort, group, dropRepeats, isEmpty } from "./index";
+function curry2(f) {
+    return function curried(a, b) {
+        return arguments.length === 2 ? f(a, b) : function (b) { return f(a, b); };
+    };
+}
+function curry3(f) {
+    return function curried(a, b, c) {
+        switch (arguments.length) {
+            case 3:
+                return f(a, b, c);
+            case 2:
+                return function (c) { return f(a, b, c); };
+            default:
+                return curry2(function (b, c) { return f(a, b, c); });
+        }
+    };
+}
+function curry4(f) {
+    return function curried(a, b, c, d) {
+        switch (arguments.length) {
+            case 4:
+                return f(a, b, c, d);
+            case 3:
+                return function (d) { return f(a, b, c, d); };
+            case 2:
+                return curry2(function (c, d) { return f(a, b, c, d); });
+            default:
+                return curry3(function (b, c, d) { return f(a, b, c, d); });
+        }
+    };
+}
+export var prepend = curry2(L.prepend);
+export var append = curry2(L.append);
+export var pair = curry2(L.pair);
+export var repeat = curry2(L.repeat);
+export var times = curry2(L.times);
+export var nth = curry2(L.nth);
+export var map = curry2(L.map);
+export var forEach = curry2(L.forEach);
+export var pluck = curry2(L.pluck);
+export var intersperse = curry2(L.intersperse);
+export var range = curry2(L.range);
+export var filter = curry2(L.filter);
+export var reject = curry2(L.reject);
+export var partition = curry2(L.partition);
+export var join = curry2(L.join);
+export var ap = curry2(L.ap);
+export var flatMap = curry2(L.flatMap);
+export var chain = flatMap;
+export var every = curry2(L.every);
+export var all = curry2(L.all);
+export var some = curry2(L.some);
+export var any = curry2(L.any);
+export var none = curry2(L.none);
+export var find = curry2(L.find);
+export var findLast = curry2(L.findLast);
+export var indexOf = curry2(L.indexOf);
+export var lastIndexOf = curry2(L.lastIndexOf);
+export var findIndex = curry2(L.findIndex);
+export var includes = curry2(L.includes);
+export var contains = includes;
+export var equals = curry2(L.equals);
+export var concat = curry2(L.concat);
+export var take = curry2(L.take);
+export var takeLast = curry2(L.takeLast);
+export var drop = curry2(L.drop);
+export var dropRepeatsWith = curry2(L.groupWith);
+export var dropLast = curry2(L.dropLast);
+export var takeWhile = curry2(L.takeWhile);
+export var takeLastWhile = curry2(L.takeLastWhile);
+export var dropWhile = curry2(L.dropWhile);
+export var splitAt = curry2(L.splitAt);
+export var splitWhen = curry2(L.splitWhen);
+export var splitEvery = curry2(L.splitEvery);
+export var sortBy = curry2(L.sortBy);
+export var sortWith = curry2(L.sortWith);
+export var groupWith = curry2(L.groupWith);
+export var zip = curry2(L.zip);
+export var sequence = curry2(L.sequence);
+export var foldl = curry3(L.foldl);
+export var reduce = foldl;
+export var scan = curry3(L.scan);
+export var foldr = curry3(L.foldr);
+export var traverse = curry3(L.traverse);
+export var equalsWith = curry3(L.equalsWith);
+export var reduceRight = foldr;
+export var update = curry3(L.update);
+export var adjust = curry3(L.adjust);
+export var slice = curry3(L.slice);
+export var remove = curry3(L.remove);
+export var insert = curry3(L.insert);
+export var insertAll = curry3(L.insertAll);
+export var zipWith = curry3(L.zipWith);
+export var foldlWhile = curry4(L.foldlWhile);
+export var reduceWhile = foldlWhile;
diff --git a/node_modules/list/dist/es/devtools.d.ts b/node_modules/list/dist/es/devtools.d.ts
new file mode 100644
index 0000000..cb0ff5c
--- /dev/null
+++ b/node_modules/list/dist/es/devtools.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/list/dist/es/devtools.js b/node_modules/list/dist/es/devtools.js
new file mode 100644
index 0000000..8369ebb
--- /dev/null
+++ b/node_modules/list/dist/es/devtools.js
@@ -0,0 +1,44 @@
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+import * as L from "./index";
+var listStyle = {
+    style: "list-style-type: none; padding: 0; margin: 0 0 0 22px; font-style: normal"
+};
+var gw = typeof window === undefined ? global : window;
+if (gw.devtoolsFormatters === undefined) {
+    gw.devtoolsFormatters = [];
+}
+function createReference(object) {
+    return ["object", { object: object }];
+}
+var l = L.list("hello", "world");
+L.intersperse(", ", l);
+gw.devtoolsFormatters.push({
+    header: function (l) {
+        if (L.isList(l)) {
+            return __spreadArrays([
+                "div",
+                { style: "font-style: italic" },
+                ["span", {}, "(" + l.length + ") list("]
+            ], L.toArray(L.intersperse(", ", L.map(createReference, l))), [
+                ["span", {}, ")"]
+            ]);
+        }
+        else {
+            return null;
+        }
+    },
+    hasBody: function (l) {
+        return l.length !== 0;
+    },
+    body: function (l) {
+        var idx = 0;
+        var children = L.map(function (o) { return ["li", ["span", {}, idx++ + ": "], createReference(o)]; }, l);
+        return __spreadArrays(["ol", listStyle], L.toArray(children));
+    }
+});
diff --git a/node_modules/list/dist/es/fantasy-land.d.ts b/node_modules/list/dist/es/fantasy-land.d.ts
new file mode 100644
index 0000000..03b44a5
--- /dev/null
+++ b/node_modules/list/dist/es/fantasy-land.d.ts
@@ -0,0 +1,15 @@
+export * from "./index";
+declare module "./index" {
+    interface List<A> {
+        "fantasy-land/equals"(l: List<A>): boolean;
+        "fantasy-land/map"<B>(f: (a: A) => B): List<B>;
+        "fantasy-land/of"<B>(b: B): List<B>;
+        "fantasy-land/ap"<B>(f: List<(a: A) => B>): List<B>;
+        "fantasy-land/chain"<B>(f: (a: A) => List<B>): List<B>;
+        "fantasy-land/filter"(predicate: (a: A) => boolean): List<A>;
+        "fantasy-land/empty"(): List<any>;
+        "fantasy-land/concat"(right: List<A>): List<A>;
+        "fantasy-land/reduce"<B>(f: (acc: B, value: A) => B, initial: B): B;
+        "fantasy-land/traverse"<A, B>(of: Of, f: (a: A) => Applicative<B>): any;
+    }
+}
diff --git a/node_modules/list/dist/es/fantasy-land.js b/node_modules/list/dist/es/fantasy-land.js
new file mode 100644
index 0000000..bcd4453
--- /dev/null
+++ b/node_modules/list/dist/es/fantasy-land.js
@@ -0,0 +1,34 @@
+import { List, equals, map, filter, empty, concat, foldl, of, ap, chain, traverse } from "./index";
+export * from "./index";
+var flOf = "fantasy-land/of";
+var flEmpty = "fantasy-land/empty";
+List.prototype["fantasy-land/equals"] = function (l) {
+    return equals(this, l);
+};
+List.prototype["fantasy-land/map"] = function (f) {
+    return map(f, this);
+};
+List.prototype[flOf] = of;
+List[flOf] = List.prototype[flOf];
+List.prototype["fantasy-land/ap"] = function (listF) {
+    return ap(listF, this);
+};
+List.prototype["fantasy-land/chain"] = function (f) {
+    return chain(f, this);
+};
+List.prototype["fantasy-land/filter"] = function (predicate) {
+    return filter(predicate, this);
+};
+List.prototype[flEmpty] = function () {
+    return empty();
+};
+List[flEmpty] = List.prototype[flEmpty];
+List.prototype["fantasy-land/concat"] = function (right) {
+    return concat(this, right);
+};
+List.prototype["fantasy-land/reduce"] = function (f, initial) {
+    return foldl(f, initial, this);
+};
+List.prototype["fantasy-land/traverse"] = function (of, f) {
+    return traverse(of, f, this);
+};
diff --git a/node_modules/list/dist/es/index.d.ts b/node_modules/list/dist/es/index.d.ts
new file mode 100644
index 0000000..dd1f850
--- /dev/null
+++ b/node_modules/list/dist/es/index.d.ts
@@ -0,0 +1,115 @@
+export declare type Sizes = number[] | undefined;
+export declare class Node {
+    sizes: Sizes;
+    array: any[];
+    constructor(sizes: Sizes, array: any[]);
+}
+export declare class List<A> implements Iterable<A> {
+    readonly bits: number;
+    readonly offset: number;
+    readonly length: number;
+    readonly prefix: A[];
+    readonly root: Node | undefined;
+    readonly suffix: A[];
+    constructor(bits: number, offset: number, length: number, prefix: A[], root: Node | undefined, suffix: A[]);
+    [Symbol.iterator](): Iterator<A>;
+    toJSON(): A[];
+}
+export declare function backwards<A>(l: List<A>): Iterable<A>;
+export declare function list<A>(...elements: A[]): List<A>;
+export declare function empty<A = any>(): List<A>;
+export declare function of<A>(a: A): List<A>;
+export declare function pair<A>(first: A, second: A): List<A>;
+export declare function from<A>(sequence: A[] | ArrayLike<A> | Iterable<A>): List<A>;
+export declare function range(start: number, end: number): List<number>;
+export declare function repeat<A>(value: A, times: number): List<A>;
+export declare function times<A>(func: (index: number) => A, times: number): List<A>;
+export declare function nth<A>(index: number, l: List<A>): A | undefined;
+export declare function prepend<A>(value: A, l: List<A>): List<A>;
+export declare function append<A>(value: A, l: List<A>): List<A>;
+export declare function length(l: List<any>): number;
+export declare function first<A>(l: List<A>): A | undefined;
+export declare const head: typeof first;
+export declare function last<A>(l: List<A>): A | undefined;
+export declare function map<A, B>(f: (a: A) => B, l: List<A>): List<B>;
+export declare function pluck<A, K extends keyof A>(key: K, l: List<A>): List<A[K]>;
+export declare function foldl<A, B>(f: (acc: B, value: A) => B, initial: B, l: List<A>): B;
+export declare const reduce: typeof foldl;
+export interface Of {
+    "fantasy-land/of"<B>(a: B): Applicative<B>;
+}
+export interface Applicative<A> {
+    "fantasy-land/map"<B>(f: (a: A) => B): Applicative<B>;
+    "fantasy-land/ap"<B>(fa: Applicative<(a: A) => B>): Applicative<B>;
+}
+export declare function traverse<A, B>(of: Of, f: (a: A) => Applicative<B>, l: List<A>): any;
+export declare function sequence<A>(ofObj: Of, l: List<Applicative<A>>): any;
+export declare function scan<A, B>(f: (acc: B, value: A) => B, initial: B, l: List<A>): List<B>;
+export declare function forEach<A>(callback: (a: A) => void, l: List<A>): void;
+export declare function filter<A, B extends A>(predicate: (a: A) => a is B, l: List<A>): List<B>;
+export declare function filter<A>(predicate: (a: A) => boolean, l: List<A>): List<A>;
+export declare function reject<A>(predicate: (a: A) => boolean, l: List<A>): List<A>;
+export declare function partition<A, B extends A>(predicate: (a: A) => a is B, l: List<A>): [List<B>, List<Exclude<A, B>>];
+export declare function partition<A>(predicate: (a: A) => boolean, l: List<A>): [List<A>, List<A>];
+export declare function join(separator: string, l: List<string>): string;
+export declare function foldr<A, B>(f: (value: A, acc: B) => B, initial: B, l: List<A>): B;
+export declare const reduceRight: typeof foldr;
+export declare function ap<A, B>(listF: List<(a: A) => B>, l: List<A>): List<B>;
+export declare function flatten<A>(nested: List<List<A>>): List<A>;
+export declare function flatMap<A, B>(f: (a: A) => List<B>, l: List<A>): List<B>;
+export declare const chain: typeof flatMap;
+export declare function foldlWhile<A, B>(predicate: (acc: B, value: A) => boolean, f: (acc: B, value: A) => B, initial: B, l: List<A>): B;
+export declare const reduceWhile: typeof foldlWhile;
+export declare function every<A>(predicate: (a: A) => boolean, l: List<A>): boolean;
+export declare const all: typeof every;
+export declare function some<A>(predicate: (a: A) => boolean, l: List<A>): boolean;
+export declare const any: typeof some;
+export declare function none<A>(predicate: (a: A) => boolean, l: List<A>): boolean;
+export declare function find<A>(predicate: (a: A) => boolean, l: List<A>): A | undefined;
+export declare function findLast<A>(predicate: (a: A) => boolean, l: List<A>): A | undefined;
+export declare function indexOf<A>(element: A, l: List<A>): number;
+export declare function lastIndexOf<A>(element: A, l: List<A>): number;
+export declare function findIndex<A>(predicate: (a: A) => boolean, l: List<A>): number;
+export declare function includes<A>(element: A, l: List<A>): boolean;
+export declare const contains: typeof includes;
+export declare function equals<A>(l1: List<A>, l2: List<A>): boolean;
+export declare function equalsWith<A>(f: (a: A, b: A) => boolean, l1: List<A>, l2: List<A>): boolean;
+export declare function concat<A>(left: List<A>, right: List<A>): List<A>;
+export declare function update<A>(index: number, a: A, l: List<A>): List<A>;
+export declare function adjust<A>(index: number, f: (a: A) => A, l: List<A>): List<A>;
+export declare function slice<A>(from: number, to: number, l: List<A>): List<A>;
+export declare function take<A>(n: number, l: List<A>): List<A>;
+export declare function takeWhile<A>(predicate: (a: A) => boolean, l: List<A>): List<A>;
+export declare function takeLastWhile<A>(predicate: (a: A) => boolean, l: List<A>): List<A>;
+export declare function dropWhile<A>(predicate: (a: A) => boolean, l: List<A>): List<A>;
+export declare function dropRepeats<A>(l: List<A>): List<A>;
+export declare function dropRepeatsWith<A>(predicate: (a: A, b: A) => Boolean, l: List<A>): List<A>;
+export declare function takeLast<A>(n: number, l: List<A>): List<A>;
+export declare function splitAt<A>(index: number, l: List<A>): [List<A>, List<A>];
+export declare function splitWhen<A>(predicate: (a: A) => boolean, l: List<A>): [List<A>, List<A>];
+export declare function splitEvery<A>(size: number, l: List<A>): List<List<A>>;
+export declare function remove<A>(from: number, amount: number, l: List<A>): List<A>;
+export declare function drop<A>(n: number, l: List<A>): List<A>;
+export declare function dropLast<A>(n: number, l: List<A>): List<A>;
+export declare function pop<A>(l: List<A>): List<A>;
+export declare const init: typeof pop;
+export declare function tail<A>(l: List<A>): List<A>;
+export declare function toArray<A>(l: List<A>): A[];
+export declare function insert<A>(index: number, element: A, l: List<A>): List<A>;
+export declare function insertAll<A>(index: number, elements: List<A>, l: List<A>): List<A>;
+export declare function reverse<A>(l: List<A>): List<A>;
+export declare function isList<A>(l: any): l is List<A>;
+export declare function zip<A, B>(as: List<A>, bs: List<B>): List<[A, B]>;
+export declare function zipWith<A, B, C>(f: (a: A, b: B) => C, as: List<A>, bs: List<B>): List<C>;
+export declare type Ordering = -1 | 0 | 1;
+export interface Ord {
+    "fantasy-land/lte"(b: any): boolean;
+}
+export declare type Comparable = number | string | Ord;
+export declare function sort<A extends Comparable>(l: List<A>): List<A>;
+export declare function sortWith<A>(comparator: (a: A, b: A) => Ordering, l: List<A>): List<A>;
+export declare function sortBy<A, B extends Comparable>(f: (a: A) => B, l: List<A>): List<A>;
+export declare function group<A>(l: List<A>): List<List<A>>;
+export declare function groupWith<A>(f: (a: A, b: A) => boolean, l: List<A>): List<List<A>>;
+export declare function intersperse<A>(separator: A, l: List<A>): List<A>;
+export declare function isEmpty(l: List<any>): boolean;
diff --git a/node_modules/list/dist/es/index.js b/node_modules/list/dist/es/index.js
new file mode 100644
index 0000000..0b067fd
--- /dev/null
+++ b/node_modules/list/dist/es/index.js
@@ -0,0 +1,1627 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var branchingFactor = 32;
+var branchBits = 5;
+var mask = 31;
+function isSetoid(a) {
+    return a && typeof a["fantasy-land/equals"] === "function";
+}
+function elementEquals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    else if (isSetoid(a)) {
+        return a["fantasy-land/equals"](b);
+    }
+    else {
+        return false;
+    }
+}
+function createPath(depth, value) {
+    var current = value;
+    for (var i = 0; i < depth; ++i) {
+        current = new Node(undefined, [current]);
+    }
+    return current;
+}
+function copyArray(source) {
+    var array = [];
+    for (var i = 0; i < source.length; ++i) {
+        array[i] = source[i];
+    }
+    return array;
+}
+function pushElements(source, target, offset, amount) {
+    for (var i = offset; i < offset + amount; ++i) {
+        target.push(source[i]);
+    }
+}
+function copyIndices(source, sourceStart, target, targetStart, length) {
+    for (var i = 0; i < length; ++i) {
+        target[targetStart + i] = source[sourceStart + i];
+    }
+}
+function arrayPrepend(value, array) {
+    var newLength = array.length + 1;
+    var result = new Array(newLength);
+    result[0] = value;
+    for (var i = 1; i < newLength; ++i) {
+        result[i] = array[i - 1];
+    }
+    return result;
+}
+function reverseArray(array) {
+    return array.slice().reverse();
+}
+function arrayFirst(array) {
+    return array[0];
+}
+function arrayLast(array) {
+    return array[array.length - 1];
+}
+var pathResult = { path: 0, index: 0, updatedOffset: 0 };
+function getPath(index, offset, depth, sizes) {
+    if (sizes === undefined && offset !== 0) {
+        pathResult.updatedOffset = 0;
+        index = handleOffset(depth, offset, index);
+    }
+    var path = (index >> (depth * branchBits)) & mask;
+    if (sizes !== undefined) {
+        while (sizes[path] <= index) {
+            path++;
+        }
+        var traversed = path === 0 ? 0 : sizes[path - 1];
+        index -= traversed;
+        pathResult.updatedOffset = offset;
+    }
+    pathResult.path = path;
+    pathResult.index = index;
+    return pathResult;
+}
+function updateNode(node, depth, index, offset, value) {
+    var _a = getPath(index, offset, depth, node.sizes), path = _a.path, newIndex = _a.index, updatedOffset = _a.updatedOffset;
+    var array = copyArray(node.array);
+    array[path] =
+        depth > 0
+            ? updateNode(array[path], depth - 1, newIndex, updatedOffset, value)
+            : value;
+    return new Node(node.sizes, array);
+}
+var Node = (function () {
+    function Node(sizes, array) {
+        this.sizes = sizes;
+        this.array = array;
+    }
+    return Node;
+}());
+export { Node };
+function cloneNode(_a) {
+    var sizes = _a.sizes, array = _a.array;
+    return new Node(sizes === undefined ? undefined : copyArray(sizes), copyArray(array));
+}
+var emptyAffix = [0];
+var affixBits = 6;
+var affixMask = 63;
+function getSuffixSize(l) {
+    return l.bits & affixMask;
+}
+function getPrefixSize(l) {
+    return (l.bits >> affixBits) & affixMask;
+}
+function getDepth(l) {
+    return l.bits >> (affixBits * 2);
+}
+function setPrefix(size, bits) {
+    return (size << affixBits) | (bits & ~(affixMask << affixBits));
+}
+function setSuffix(size, bits) {
+    return size | (bits & ~affixMask);
+}
+function setDepth(depth, bits) {
+    return ((depth << (affixBits * 2)) | (bits & (affixMask | (affixMask << affixBits))));
+}
+function incrementPrefix(bits) {
+    return bits + (1 << affixBits);
+}
+function incrementSuffix(bits) {
+    return bits + 1;
+}
+function incrementDepth(bits) {
+    return bits + (1 << (affixBits * 2));
+}
+function decrementDepth(bits) {
+    return bits - (1 << (affixBits * 2));
+}
+var List = (function () {
+    function List(bits, offset, length, prefix, root, suffix) {
+        this.bits = bits;
+        this.offset = offset;
+        this.length = length;
+        this.prefix = prefix;
+        this.root = root;
+        this.suffix = suffix;
+    }
+    List.prototype[Symbol.iterator] = function () {
+        return new ForwardListIterator(this);
+    };
+    List.prototype.toJSON = function () {
+        return toArray(this);
+    };
+    return List;
+}());
+export { List };
+function cloneList(l) {
+    return new List(l.bits, l.offset, l.length, l.prefix, l.root, l.suffix);
+}
+var ListIterator = (function () {
+    function ListIterator(l, direction) {
+        this.l = l;
+        this.result = { done: false, value: undefined };
+        this.idx = direction === 1 ? -1 : l.length;
+        this.prefixSize = getPrefixSize(l);
+        this.middleSize = l.length - getSuffixSize(l);
+        if (l.root !== undefined) {
+            var depth = getDepth(l);
+            this.stack = new Array(depth + 1);
+            this.indices = new Array(depth + 1);
+            var currentNode = l.root.array;
+            for (var i = depth; 0 <= i; --i) {
+                this.stack[i] = currentNode;
+                var idx = direction === 1 ? 0 : currentNode.length - 1;
+                this.indices[i] = idx;
+                currentNode = currentNode[idx].array;
+            }
+            this.indices[0] -= direction;
+        }
+    }
+    return ListIterator;
+}());
+var ForwardListIterator = (function (_super) {
+    __extends(ForwardListIterator, _super);
+    function ForwardListIterator(l) {
+        return _super.call(this, l, 1) || this;
+    }
+    ForwardListIterator.prototype.nextInTree = function () {
+        for (var i = 0; ++this.indices[i] === this.stack[i].length; ++i) {
+            this.indices[i] = 0;
+        }
+        for (; 0 < i; --i) {
+            this.stack[i - 1] = this.stack[i][this.indices[i]].array;
+        }
+    };
+    ForwardListIterator.prototype.next = function () {
+        var newVal;
+        var idx = ++this.idx;
+        if (idx < this.prefixSize) {
+            newVal = this.l.prefix[this.prefixSize - idx - 1];
+        }
+        else if (idx < this.middleSize) {
+            this.nextInTree();
+            newVal = this.stack[0][this.indices[0]];
+        }
+        else if (idx < this.l.length) {
+            newVal = this.l.suffix[idx - this.middleSize];
+        }
+        else {
+            this.result.done = true;
+        }
+        this.result.value = newVal;
+        return this.result;
+    };
+    return ForwardListIterator;
+}(ListIterator));
+var BackwardsListIterator = (function (_super) {
+    __extends(BackwardsListIterator, _super);
+    function BackwardsListIterator(l) {
+        return _super.call(this, l, -1) || this;
+    }
+    BackwardsListIterator.prototype.prevInTree = function () {
+        for (var i = 0; this.indices[i] === 0; ++i) { }
+        --this.indices[i];
+        for (; 0 < i; --i) {
+            var n = this.stack[i][this.indices[i]].array;
+            this.stack[i - 1] = n;
+            this.indices[i - 1] = n.length - 1;
+        }
+    };
+    BackwardsListIterator.prototype.next = function () {
+        var newVal;
+        var idx = --this.idx;
+        if (this.middleSize <= idx) {
+            newVal = this.l.suffix[idx - this.middleSize];
+        }
+        else if (this.prefixSize <= idx) {
+            this.prevInTree();
+            newVal = this.stack[0][this.indices[0]];
+        }
+        else if (0 <= idx) {
+            newVal = this.l.prefix[this.prefixSize - idx - 1];
+        }
+        else {
+            this.result.done = true;
+        }
+        this.result.value = newVal;
+        return this.result;
+    };
+    return BackwardsListIterator;
+}(ListIterator));
+export function backwards(l) {
+    var _a;
+    return _a = {},
+        _a[Symbol.iterator] = function () {
+            return new BackwardsListIterator(l);
+        },
+        _a;
+}
+function emptyPushable() {
+    return new List(0, 0, 0, [], undefined, []);
+}
+function push(value, l) {
+    var suffixSize = getSuffixSize(l);
+    if (l.length === 0) {
+        l.bits = setPrefix(1, l.bits);
+        l.prefix = [value];
+    }
+    else if (suffixSize < 32) {
+        l.bits = incrementSuffix(l.bits);
+        l.suffix.push(value);
+    }
+    else if (l.root === undefined) {
+        l.root = new Node(undefined, l.suffix);
+        l.suffix = [value];
+        l.bits = setSuffix(1, l.bits);
+    }
+    else {
+        var newNode = new Node(undefined, l.suffix);
+        var index = l.length - 1 - 32 + 1;
+        var current = l.root;
+        var depth = getDepth(l);
+        l.suffix = [value];
+        l.bits = setSuffix(1, l.bits);
+        if (index - 1 < Math.pow(branchingFactor, (depth + 1))) {
+            for (; depth >= 0; --depth) {
+                var path = (index >> (depth * branchBits)) & mask;
+                if (path < current.array.length) {
+                    current = current.array[path];
+                }
+                else {
+                    current.array.push(createPath(depth - 1, newNode));
+                    break;
+                }
+            }
+        }
+        else {
+            l.bits = incrementDepth(l.bits);
+            l.root = new Node(undefined, [l.root, createPath(depth, newNode)]);
+        }
+    }
+    l.length++;
+    return l;
+}
+export function list() {
+    var elements = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        elements[_i] = arguments[_i];
+    }
+    var l = emptyPushable();
+    for (var _a = 0, elements_1 = elements; _a < elements_1.length; _a++) {
+        var element = elements_1[_a];
+        push(element, l);
+    }
+    return l;
+}
+export function empty() {
+    return new List(0, 0, 0, emptyAffix, undefined, emptyAffix);
+}
+export function of(a) {
+    return list(a);
+}
+export function pair(first, second) {
+    return new List(2, 0, 2, emptyAffix, undefined, [first, second]);
+}
+export function from(sequence) {
+    var l = emptyPushable();
+    if (sequence.length > 0 && (sequence[0] !== undefined || 0 in sequence)) {
+        for (var i = 0; i < sequence.length; ++i) {
+            push(sequence[i], l);
+        }
+    }
+    else if (Symbol.iterator in sequence) {
+        var iterator = sequence[Symbol.iterator]();
+        var cur = void 0;
+        while (!(cur = iterator.next()).done) {
+            push(cur.value, l);
+        }
+    }
+    return l;
+}
+export function range(start, end) {
+    var list = emptyPushable();
+    for (var i = start; i < end; ++i) {
+        push(i, list);
+    }
+    return list;
+}
+export function repeat(value, times) {
+    var l = emptyPushable();
+    while (--times >= 0) {
+        push(value, l);
+    }
+    return l;
+}
+export function times(func, times) {
+    var l = emptyPushable();
+    for (var i = 0; i < times; i++) {
+        push(func(i), l);
+    }
+    return l;
+}
+function nodeNthDense(node, depth, index) {
+    var current = node;
+    for (; depth >= 0; --depth) {
+        current = current.array[(index >> (depth * branchBits)) & mask];
+    }
+    return current;
+}
+function handleOffset(depth, offset, index) {
+    index += offset;
+    for (; depth >= 0; --depth) {
+        index = index - (offset & (mask << (depth * branchBits)));
+        if (((index >> (depth * branchBits)) & mask) !== 0) {
+            break;
+        }
+    }
+    return index;
+}
+function nodeNth(node, depth, offset, index) {
+    var path;
+    var current = node;
+    while (current.sizes !== undefined) {
+        path = (index >> (depth * branchBits)) & mask;
+        while (current.sizes[path] <= index) {
+            path++;
+        }
+        if (path !== 0) {
+            index -= current.sizes[path - 1];
+            offset = 0;
+        }
+        depth--;
+        current = current.array[path];
+    }
+    return nodeNthDense(current, depth, offset === 0 ? index : handleOffset(depth, offset, index));
+}
+export function nth(index, l) {
+    if (index < 0 || l.length <= index) {
+        return undefined;
+    }
+    var prefixSize = getPrefixSize(l);
+    var suffixSize = getSuffixSize(l);
+    if (index < prefixSize) {
+        return l.prefix[prefixSize - index - 1];
+    }
+    else if (index >= l.length - suffixSize) {
+        return l.suffix[index - (l.length - suffixSize)];
+    }
+    var offset = l.offset;
+    var depth = getDepth(l);
+    return l.root.sizes === undefined
+        ? nodeNthDense(l.root, depth, offset === 0
+            ? index - prefixSize
+            : handleOffset(depth, offset, index - prefixSize))
+        : nodeNth(l.root, depth, offset, index - prefixSize);
+}
+function setSizes(node, height) {
+    var sum = 0;
+    var sizeTable = [];
+    for (var i = 0; i < node.array.length; ++i) {
+        sum += sizeOfSubtree(node.array[i], height - 1);
+        sizeTable[i] = sum;
+    }
+    node.sizes = sizeTable;
+    return node;
+}
+function sizeOfSubtree(node, height) {
+    if (height !== 0) {
+        if (node.sizes !== undefined) {
+            return arrayLast(node.sizes);
+        }
+        else {
+            var lastSize = sizeOfSubtree(arrayLast(node.array), height - 1);
+            return ((node.array.length - 1) << (height * branchBits)) + lastSize;
+        }
+    }
+    else {
+        return node.array.length;
+    }
+}
+function affixPush(a, array, length) {
+    if (array.length === length) {
+        array.push(a);
+        return array;
+    }
+    else {
+        var newArray = [];
+        copyIndices(array, 0, newArray, 0, length);
+        newArray.push(a);
+        return newArray;
+    }
+}
+export function prepend(value, l) {
+    var prefixSize = getPrefixSize(l);
+    if (prefixSize < 32) {
+        return new List(incrementPrefix(l.bits), l.offset, l.length + 1, affixPush(value, l.prefix, prefixSize), l.root, l.suffix);
+    }
+    else {
+        var newList = cloneList(l);
+        prependNodeToTree(newList, reverseArray(l.prefix));
+        var newPrefix = [value];
+        newList.prefix = newPrefix;
+        newList.length++;
+        newList.bits = setPrefix(1, newList.bits);
+        return newList;
+    }
+}
+function copyLeft(l, k) {
+    var currentNode = cloneNode(l.root);
+    l.root = currentNode;
+    for (var i = 1; i < k; ++i) {
+        var index = 0;
+        if (currentNode.sizes !== undefined) {
+            for (var i_1 = 0; i_1 < currentNode.sizes.length; ++i_1) {
+                currentNode.sizes[i_1] += 32;
+            }
+        }
+        var newNode = cloneNode(currentNode.array[index]);
+        currentNode.array[index] = newNode;
+        currentNode = newNode;
+    }
+    return currentNode;
+}
+function nodePrepend(value, size, node) {
+    var array = arrayPrepend(value, node.array);
+    var sizes = undefined;
+    if (node.sizes !== undefined) {
+        sizes = new Array(node.sizes.length + 1);
+        sizes[0] = size;
+        for (var i = 0; i < node.sizes.length; ++i) {
+            sizes[i + 1] = node.sizes[i] + size;
+        }
+    }
+    return new Node(sizes, array);
+}
+function prependTopTree(l, depth, node) {
+    var newOffset;
+    if (l.root.array.length < branchingFactor) {
+        newOffset = Math.pow(32, depth) - 32;
+        l.root = new Node(undefined, arrayPrepend(createPath(depth - 1, node), l.root.array));
+    }
+    else {
+        l.bits = incrementDepth(l.bits);
+        var sizes = l.root.sizes === undefined
+            ? undefined
+            : [32, arrayLast(l.root.sizes) + 32];
+        newOffset = depth === 0 ? 0 : Math.pow(32, (depth + 1)) - 32;
+        l.root = new Node(sizes, [createPath(depth, node), l.root]);
+    }
+    return newOffset;
+}
+function prependNodeToTree(l, array) {
+    if (l.root === undefined) {
+        if (getSuffixSize(l) === 0) {
+            l.bits = setSuffix(array.length, l.bits);
+            l.suffix = array;
+        }
+        else {
+            l.root = new Node(undefined, array);
+        }
+        return l;
+    }
+    else {
+        var node = new Node(undefined, array);
+        var depth = getDepth(l);
+        var newOffset_1 = 0;
+        if (l.root.sizes === undefined) {
+            if (l.offset !== 0) {
+                newOffset_1 = l.offset - branchingFactor;
+                l.root = prependDense(l.root, depth, l.offset, node);
+            }
+            else {
+                newOffset_1 = prependTopTree(l, depth, node);
+            }
+        }
+        else {
+            var copyableCount = 0;
+            var nodesTraversed = 0;
+            var currentNode = l.root;
+            while (currentNode.sizes !== undefined && nodesTraversed < depth) {
+                ++nodesTraversed;
+                if (currentNode.array.length < 32) {
+                    copyableCount = nodesTraversed;
+                }
+                currentNode = currentNode.array[0];
+            }
+            if (l.offset !== 0) {
+                var copiedNode = copyLeft(l, nodesTraversed);
+                for (var i = 0; i < copiedNode.sizes.length; ++i) {
+                    copiedNode.sizes[i] += branchingFactor;
+                }
+                copiedNode.array[0] = prependDense(copiedNode.array[0], depth - nodesTraversed, l.offset, node);
+                l.offset = l.offset - branchingFactor;
+                return l;
+            }
+            else {
+                if (copyableCount === 0) {
+                    l.offset = prependTopTree(l, depth, node);
+                }
+                else {
+                    var parent_1;
+                    var prependableNode = void 0;
+                    if (copyableCount > 1) {
+                        parent_1 = copyLeft(l, copyableCount - 1);
+                        prependableNode = parent_1.array[0];
+                    }
+                    else {
+                        parent_1 = undefined;
+                        prependableNode = l.root;
+                    }
+                    var path = createPath(depth - copyableCount, node);
+                    l.offset = Math.pow(32, (depth - copyableCount + 1)) - 32;
+                    var prepended = nodePrepend(path, 32, prependableNode);
+                    if (parent_1 === undefined) {
+                        l.root = prepended;
+                    }
+                    else {
+                        parent_1.array[0] = prepended;
+                    }
+                }
+                return l;
+            }
+        }
+        l.offset = newOffset_1;
+        return l;
+    }
+}
+function prependDense(node, depth, offset, value) {
+    var curOffset = (offset >> (depth * branchBits)) & mask;
+    var path = (((offset - 1) >> (depth * branchBits)) & mask) - curOffset;
+    if (path < 0) {
+        return new Node(undefined, arrayPrepend(createPath(depth - 1, value), node.array));
+    }
+    else {
+        var array = copyArray(node.array);
+        array[0] = prependDense(array[0], depth - 1, offset, value);
+        return new Node(undefined, array);
+    }
+}
+export function append(value, l) {
+    var suffixSize = getSuffixSize(l);
+    if (suffixSize < 32) {
+        return new List(incrementSuffix(l.bits), l.offset, l.length + 1, l.prefix, l.root, affixPush(value, l.suffix, suffixSize));
+    }
+    var newSuffix = [value];
+    var newList = cloneList(l);
+    appendNodeToTree(newList, l.suffix);
+    newList.suffix = newSuffix;
+    newList.length++;
+    newList.bits = setSuffix(1, newList.bits);
+    return newList;
+}
+export function length(l) {
+    return l.length;
+}
+export function first(l) {
+    var prefixSize = getPrefixSize(l);
+    return prefixSize !== 0
+        ? l.prefix[prefixSize - 1]
+        : l.length !== 0
+            ? l.suffix[0]
+            : undefined;
+}
+export var head = first;
+export function last(l) {
+    var suffixSize = getSuffixSize(l);
+    return suffixSize !== 0
+        ? l.suffix[suffixSize - 1]
+        : l.length !== 0
+            ? l.prefix[0]
+            : undefined;
+}
+function mapArray(f, array) {
+    var result = new Array(array.length);
+    for (var i = 0; i < array.length; ++i) {
+        result[i] = f(array[i]);
+    }
+    return result;
+}
+function mapNode(f, node, depth) {
+    if (depth !== 0) {
+        var array = node.array;
+        var result = new Array(array.length);
+        for (var i = 0; i < array.length; ++i) {
+            result[i] = mapNode(f, array[i], depth - 1);
+        }
+        return new Node(node.sizes, result);
+    }
+    else {
+        return new Node(undefined, mapArray(f, node.array));
+    }
+}
+function mapPrefix(f, prefix, length) {
+    var newPrefix = new Array(length);
+    for (var i = length - 1; 0 <= i; --i) {
+        newPrefix[i] = f(prefix[i]);
+    }
+    return newPrefix;
+}
+function mapAffix(f, suffix, length) {
+    var newSuffix = new Array(length);
+    for (var i = 0; i < length; ++i) {
+        newSuffix[i] = f(suffix[i]);
+    }
+    return newSuffix;
+}
+export function map(f, l) {
+    return new List(l.bits, l.offset, l.length, mapPrefix(f, l.prefix, getPrefixSize(l)), l.root === undefined ? undefined : mapNode(f, l.root, getDepth(l)), mapAffix(f, l.suffix, getSuffixSize(l)));
+}
+export function pluck(key, l) {
+    return map(function (a) { return a[key]; }, l);
+}
+function foldlSuffix(f, acc, array, length) {
+    for (var i = 0; i < length; ++i) {
+        acc = f(acc, array[i]);
+    }
+    return acc;
+}
+function foldlPrefix(f, acc, array, length) {
+    for (var i = length - 1; 0 <= i; --i) {
+        acc = f(acc, array[i]);
+    }
+    return acc;
+}
+function foldlNode(f, acc, node, depth) {
+    var array = node.array;
+    if (depth === 0) {
+        return foldlSuffix(f, acc, array, array.length);
+    }
+    for (var i = 0; i < array.length; ++i) {
+        acc = foldlNode(f, acc, array[i], depth - 1);
+    }
+    return acc;
+}
+export function foldl(f, initial, l) {
+    var suffixSize = getSuffixSize(l);
+    var prefixSize = getPrefixSize(l);
+    initial = foldlPrefix(f, initial, l.prefix, prefixSize);
+    if (l.root !== undefined) {
+        initial = foldlNode(f, initial, l.root, getDepth(l));
+    }
+    return foldlSuffix(f, initial, l.suffix, suffixSize);
+}
+export var reduce = foldl;
+export function traverse(of, f, l) {
+    return foldr(function (a, fl) {
+        return fl["fantasy-land/ap"](f(a)["fantasy-land/map"](function (a) { return function (l) { return prepend(a, l); }; }));
+    }, of["fantasy-land/of"](empty()), l);
+}
+export function sequence(ofObj, l) {
+    return traverse(ofObj, function (a) { return a; }, l);
+}
+export function scan(f, initial, l) {
+    return foldl(function (l2, a) { return push(f(last(l2), a), l2); }, push(initial, emptyPushable()), l);
+}
+export function forEach(callback, l) {
+    foldl(function (_, element) { return callback(element); }, undefined, l);
+}
+export function filter(predicate, l) {
+    return foldl(function (acc, a) { return (predicate(a) ? push(a, acc) : acc); }, emptyPushable(), l);
+}
+export function reject(predicate, l) {
+    return foldl(function (acc, a) { return (predicate(a) ? acc : push(a, acc)); }, emptyPushable(), l);
+}
+export function partition(predicate, l) {
+    return foldl(function (arr, a) { return (predicate(a) ? push(a, arr[0]) : push(a, arr[1]), arr); }, [emptyPushable(), emptyPushable()], l);
+}
+export function join(separator, l) {
+    return foldl(function (a, b) { return (a.length === 0 ? b : a + separator + b); }, "", l);
+}
+function foldrSuffix(f, initial, array, length) {
+    var acc = initial;
+    for (var i = length - 1; 0 <= i; --i) {
+        acc = f(array[i], acc);
+    }
+    return acc;
+}
+function foldrPrefix(f, initial, array, length) {
+    var acc = initial;
+    for (var i = 0; i < length; ++i) {
+        acc = f(array[i], acc);
+    }
+    return acc;
+}
+function foldrNode(f, initial, _a, depth) {
+    var array = _a.array;
+    if (depth === 0) {
+        return foldrSuffix(f, initial, array, array.length);
+    }
+    var acc = initial;
+    for (var i = array.length - 1; 0 <= i; --i) {
+        acc = foldrNode(f, acc, array[i], depth - 1);
+    }
+    return acc;
+}
+export function foldr(f, initial, l) {
+    var suffixSize = getSuffixSize(l);
+    var prefixSize = getPrefixSize(l);
+    var acc = foldrSuffix(f, initial, l.suffix, suffixSize);
+    if (l.root !== undefined) {
+        acc = foldrNode(f, acc, l.root, getDepth(l));
+    }
+    return foldrPrefix(f, acc, l.prefix, prefixSize);
+}
+export var reduceRight = foldr;
+export function ap(listF, l) {
+    return flatten(map(function (f) { return map(f, l); }, listF));
+}
+export function flatten(nested) {
+    return foldl(concat, empty(), nested);
+}
+export function flatMap(f, l) {
+    return flatten(map(f, l));
+}
+export var chain = flatMap;
+function foldlArrayCb(cb, state, array, from, to) {
+    for (var i = from; i < to && cb(array[i], state); ++i) { }
+    return i === to;
+}
+function foldrArrayCb(cb, state, array, from, to) {
+    for (var i = from - 1; to <= i && cb(array[i], state); --i) { }
+    return i === to - 1;
+}
+function foldlNodeCb(cb, state, node, depth) {
+    var array = node.array;
+    if (depth === 0) {
+        return foldlArrayCb(cb, state, array, 0, array.length);
+    }
+    var to = array.length;
+    for (var i = 0; i < to; ++i) {
+        if (!foldlNodeCb(cb, state, array[i], depth - 1)) {
+            return false;
+        }
+    }
+    return true;
+}
+function foldlCb(cb, state, l) {
+    var prefixSize = getPrefixSize(l);
+    if (!foldrArrayCb(cb, state, l.prefix, prefixSize, 0) ||
+        (l.root !== undefined && !foldlNodeCb(cb, state, l.root, getDepth(l)))) {
+        return state;
+    }
+    var suffixSize = getSuffixSize(l);
+    foldlArrayCb(cb, state, l.suffix, 0, suffixSize);
+    return state;
+}
+function foldrNodeCb(cb, state, node, depth) {
+    var array = node.array;
+    if (depth === 0) {
+        return foldrArrayCb(cb, state, array, array.length, 0);
+    }
+    for (var i = array.length - 1; 0 <= i; --i) {
+        if (!foldrNodeCb(cb, state, array[i], depth - 1)) {
+            return false;
+        }
+    }
+    return true;
+}
+function foldrCb(cb, state, l) {
+    var suffixSize = getSuffixSize(l);
+    var prefixSize = getPrefixSize(l);
+    if (!foldrArrayCb(cb, state, l.suffix, suffixSize, 0) ||
+        (l.root !== undefined && !foldrNodeCb(cb, state, l.root, getDepth(l)))) {
+        return state;
+    }
+    var prefix = l.prefix;
+    foldlArrayCb(cb, state, l.prefix, prefix.length - prefixSize, prefix.length);
+    return state;
+}
+function foldlWhileCb(a, state) {
+    if (state.predicate(state.result, a) === false) {
+        return false;
+    }
+    state.result = state.f(state.result, a);
+    return true;
+}
+export function foldlWhile(predicate, f, initial, l) {
+    return foldlCb(foldlWhileCb, { predicate: predicate, f: f, result: initial }, l).result;
+}
+export var reduceWhile = foldlWhile;
+function everyCb(value, state) {
+    return (state.result = state.predicate(value));
+}
+export function every(predicate, l) {
+    return foldlCb(everyCb, { predicate: predicate, result: true }, l).result;
+}
+export var all = every;
+function someCb(value, state) {
+    return !(state.result = state.predicate(value));
+}
+export function some(predicate, l) {
+    return foldlCb(someCb, { predicate: predicate, result: false }, l).result;
+}
+export var any = some;
+export function none(predicate, l) {
+    return !some(predicate, l);
+}
+function findCb(value, state) {
+    if (state.predicate(value)) {
+        state.result = value;
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+export function find(predicate, l) {
+    return foldlCb(findCb, { predicate: predicate, result: undefined }, l)
+        .result;
+}
+export function findLast(predicate, l) {
+    return foldrCb(findCb, { predicate: predicate, result: undefined }, l)
+        .result;
+}
+function indexOfCb(value, state) {
+    ++state.index;
+    return !(state.found = elementEquals(value, state.element));
+}
+export function indexOf(element, l) {
+    var state = { element: element, found: false, index: -1 };
+    foldlCb(indexOfCb, state, l);
+    return state.found ? state.index : -1;
+}
+export function lastIndexOf(element, l) {
+    var state = { element: element, found: false, index: 0 };
+    foldrCb(indexOfCb, state, l);
+    return state.found ? l.length - state.index : -1;
+}
+function findIndexCb(value, state) {
+    ++state.index;
+    return !(state.found = state.predicate(value));
+}
+export function findIndex(predicate, l) {
+    var _a = foldlCb(findIndexCb, { predicate: predicate, found: false, index: -1 }, l), found = _a.found, index = _a.index;
+    return found ? index : -1;
+}
+var containsState = {
+    element: undefined,
+    result: false
+};
+function containsCb(value, state) {
+    return !(state.result = value === state.element);
+}
+export function includes(element, l) {
+    containsState.element = element;
+    containsState.result = false;
+    return foldlCb(containsCb, containsState, l).result;
+}
+export var contains = includes;
+function equalsCb(value2, state) {
+    var value = state.iterator.next().value;
+    return (state.equals = state.f(value, value2));
+}
+export function equals(l1, l2) {
+    return equalsWith(elementEquals, l1, l2);
+}
+export function equalsWith(f, l1, l2) {
+    if (l1 === l2) {
+        return true;
+    }
+    else if (l1.length !== l2.length) {
+        return false;
+    }
+    else {
+        var s = { iterator: l2[Symbol.iterator](), equals: true, f: f };
+        return foldlCb(equalsCb, s, l1).equals;
+    }
+}
+var eMax = 2;
+function createConcatPlan(array) {
+    var sizes = [];
+    var sum = 0;
+    for (var i_2 = 0; i_2 < array.length; ++i_2) {
+        sum += array[i_2].array.length;
+        sizes[i_2] = array[i_2].array.length;
+    }
+    var optimalLength = Math.ceil(sum / branchingFactor);
+    var n = array.length;
+    var i = 0;
+    if (optimalLength + eMax >= n) {
+        return undefined;
+    }
+    while (optimalLength + eMax < n) {
+        while (sizes[i] > branchingFactor - eMax / 2) {
+            ++i;
+        }
+        var remaining = sizes[i];
+        do {
+            var size = Math.min(remaining + sizes[i + 1], branchingFactor);
+            sizes[i] = size;
+            remaining = remaining - (size - sizes[i + 1]);
+            ++i;
+        } while (remaining > 0);
+        for (var j = i; j <= n - 1; ++j) {
+            sizes[j] = sizes[j + 1];
+        }
+        --i;
+        --n;
+    }
+    sizes.length = n;
+    return sizes;
+}
+function concatNodeMerge(left, center, right) {
+    var array = [];
+    if (left !== undefined) {
+        for (var i = 0; i < left.array.length - 1; ++i) {
+            array.push(left.array[i]);
+        }
+    }
+    for (var i = 0; i < center.array.length; ++i) {
+        array.push(center.array[i]);
+    }
+    if (right !== undefined) {
+        for (var i = 1; i < right.array.length; ++i) {
+            array.push(right.array[i]);
+        }
+    }
+    return array;
+}
+function executeConcatPlan(merged, plan, height) {
+    var result = [];
+    var sourceIdx = 0;
+    var offset = 0;
+    for (var _i = 0, plan_1 = plan; _i < plan_1.length; _i++) {
+        var toMove = plan_1[_i];
+        var source = merged[sourceIdx].array;
+        if (toMove === source.length && offset === 0) {
+            result.push(merged[sourceIdx]);
+            ++sourceIdx;
+        }
+        else {
+            var node = new Node(undefined, []);
+            while (toMove > 0) {
+                var available = source.length - offset;
+                var itemsToCopy = Math.min(toMove, available);
+                pushElements(source, node.array, offset, itemsToCopy);
+                if (toMove >= available) {
+                    ++sourceIdx;
+                    source = merged[sourceIdx].array;
+                    offset = 0;
+                }
+                else {
+                    offset += itemsToCopy;
+                }
+                toMove -= itemsToCopy;
+            }
+            if (height > 1) {
+                setSizes(node, height - 1);
+            }
+            result.push(node);
+        }
+    }
+    return result;
+}
+function rebalance(left, center, right, height, top) {
+    var merged = concatNodeMerge(left, center, right);
+    var plan = createConcatPlan(merged);
+    var balanced = plan !== undefined ? executeConcatPlan(merged, plan, height) : merged;
+    if (balanced.length <= branchingFactor) {
+        if (top === true) {
+            return new Node(undefined, balanced);
+        }
+        else {
+            return new Node(undefined, [
+                setSizes(new Node(undefined, balanced), height)
+            ]);
+        }
+    }
+    else {
+        return new Node(undefined, [
+            setSizes(new Node(undefined, balanced.slice(0, branchingFactor)), height),
+            setSizes(new Node(undefined, balanced.slice(branchingFactor)), height)
+        ]);
+    }
+}
+function concatSubTree(left, lDepth, right, rDepth, isTop) {
+    if (lDepth > rDepth) {
+        var c = concatSubTree(arrayLast(left.array), lDepth - 1, right, rDepth, false);
+        return rebalance(left, c, undefined, lDepth, isTop);
+    }
+    else if (lDepth < rDepth) {
+        var c = concatSubTree(left, lDepth, arrayFirst(right.array), rDepth - 1, false);
+        return rebalance(undefined, c, right, rDepth, isTop);
+    }
+    else if (lDepth === 0) {
+        return new Node(undefined, [left, right]);
+    }
+    else {
+        var c = concatSubTree(arrayLast(left.array), lDepth - 1, arrayFirst(right.array), rDepth - 1, false);
+        return rebalance(left, c, right, lDepth, isTop);
+    }
+}
+function getHeight(node) {
+    if (node.array[0] instanceof Node) {
+        return 1 + getHeight(node.array[0]);
+    }
+    else {
+        return 0;
+    }
+}
+function appendNodeToTree(l, array) {
+    if (l.root === undefined) {
+        if (getPrefixSize(l) === 0) {
+            l.bits = setPrefix(array.length, l.bits);
+            l.prefix = reverseArray(array);
+        }
+        else {
+            l.root = new Node(undefined, array);
+        }
+        return l;
+    }
+    var depth = getDepth(l);
+    var index = handleOffset(depth, l.offset, l.length - 1 - getPrefixSize(l));
+    var nodesToCopy = 0;
+    var nodesVisited = 0;
+    var shift = depth * 5;
+    var currentNode = l.root;
+    if (Math.pow(32, (depth + 1)) < index) {
+        shift = 0;
+        nodesVisited = depth;
+    }
+    while (shift > 5) {
+        var childIndex = void 0;
+        if (currentNode.sizes === undefined) {
+            childIndex = (index >> shift) & mask;
+            index &= ~(mask << shift);
+        }
+        else {
+            childIndex = currentNode.array.length - 1;
+            index -= currentNode.sizes[childIndex - 1];
+        }
+        nodesVisited++;
+        if (childIndex < mask) {
+            nodesToCopy = nodesVisited;
+        }
+        currentNode = currentNode.array[childIndex];
+        if (currentNode === undefined) {
+            nodesToCopy = nodesVisited;
+            shift = 5;
+        }
+        shift -= 5;
+    }
+    if (shift !== 0) {
+        nodesVisited++;
+        if (currentNode.array.length < branchingFactor) {
+            nodesToCopy = nodesVisited;
+        }
+    }
+    var node = new Node(undefined, array);
+    if (nodesToCopy === 0) {
+        var newPath = nodesVisited === 0 ? node : createPath(nodesVisited, node);
+        var newRoot = new Node(undefined, [l.root, newPath]);
+        l.root = newRoot;
+        l.bits = incrementDepth(l.bits);
+    }
+    else {
+        var copiedNode = copyFirstK(l, nodesToCopy, array.length);
+        copiedNode.array.push(createPath(depth - nodesToCopy, node));
+    }
+    return l;
+}
+function copyFirstK(newList, k, leafSize) {
+    var currentNode = cloneNode(newList.root);
+    newList.root = currentNode;
+    for (var i = 1; i < k; ++i) {
+        var index = currentNode.array.length - 1;
+        if (currentNode.sizes !== undefined) {
+            currentNode.sizes[index] += leafSize;
+        }
+        var newNode = cloneNode(currentNode.array[index]);
+        currentNode.array[index] = newNode;
+        currentNode = newNode;
+    }
+    if (currentNode.sizes !== undefined) {
+        currentNode.sizes.push(arrayLast(currentNode.sizes) + leafSize);
+    }
+    return currentNode;
+}
+var concatBuffer = new Array(3);
+function concatAffixes(left, right) {
+    var nr = 0;
+    var arrIdx = 0;
+    var i = 0;
+    var length = getSuffixSize(left);
+    concatBuffer[nr] = [];
+    for (i = 0; i < length; ++i) {
+        concatBuffer[nr][arrIdx++] = left.suffix[i];
+    }
+    length = getPrefixSize(right);
+    for (i = 0; i < length; ++i) {
+        if (arrIdx === 32) {
+            arrIdx = 0;
+            ++nr;
+            concatBuffer[nr] = [];
+        }
+        concatBuffer[nr][arrIdx++] = right.prefix[length - 1 - i];
+    }
+    length = getSuffixSize(right);
+    for (i = 0; i < length; ++i) {
+        if (arrIdx === 32) {
+            arrIdx = 0;
+            ++nr;
+            concatBuffer[nr] = [];
+        }
+        concatBuffer[nr][arrIdx++] = right.suffix[i];
+    }
+    return nr;
+}
+export function concat(left, right) {
+    if (left.length === 0) {
+        return right;
+    }
+    else if (right.length === 0) {
+        return left;
+    }
+    var newSize = left.length + right.length;
+    var rightSuffixSize = getSuffixSize(right);
+    var newList = cloneList(left);
+    if (right.root === undefined) {
+        var nrOfAffixes = concatAffixes(left, right);
+        for (var i = 0; i < nrOfAffixes; ++i) {
+            newList = appendNodeToTree(newList, concatBuffer[i]);
+            newList.length += concatBuffer[i].length;
+            concatBuffer[i] = undefined;
+        }
+        newList.length = newSize;
+        newList.suffix = concatBuffer[nrOfAffixes];
+        newList.bits = setSuffix(concatBuffer[nrOfAffixes].length, newList.bits);
+        concatBuffer[nrOfAffixes] = undefined;
+        return newList;
+    }
+    else {
+        var leftSuffixSize = getSuffixSize(left);
+        if (leftSuffixSize > 0) {
+            newList = appendNodeToTree(newList, left.suffix.slice(0, leftSuffixSize));
+            newList.length += leftSuffixSize;
+        }
+        newList = appendNodeToTree(newList, right.prefix.slice(0, getPrefixSize(right)).reverse());
+        var newNode = concatSubTree(newList.root, getDepth(newList), right.root, getDepth(right), true);
+        var newDepth = getHeight(newNode);
+        setSizes(newNode, newDepth);
+        newList.root = newNode;
+        newList.offset &= ~(mask << (getDepth(left) * branchBits));
+        newList.length = newSize;
+        newList.bits = setSuffix(rightSuffixSize, setDepth(newDepth, newList.bits));
+        newList.suffix = right.suffix;
+        return newList;
+    }
+}
+export function update(index, a, l) {
+    if (index < 0 || l.length <= index) {
+        return l;
+    }
+    var prefixSize = getPrefixSize(l);
+    var suffixSize = getSuffixSize(l);
+    var newList = cloneList(l);
+    if (index < prefixSize) {
+        var newPrefix = copyArray(newList.prefix);
+        newPrefix[newPrefix.length - index - 1] = a;
+        newList.prefix = newPrefix;
+    }
+    else if (index >= l.length - suffixSize) {
+        var newSuffix = copyArray(newList.suffix);
+        newSuffix[index - (l.length - suffixSize)] = a;
+        newList.suffix = newSuffix;
+    }
+    else {
+        newList.root = updateNode(l.root, getDepth(l), index - prefixSize, l.offset, a);
+    }
+    return newList;
+}
+export function adjust(index, f, l) {
+    if (index < 0 || l.length <= index) {
+        return l;
+    }
+    return update(index, f(nth(index, l)), l);
+}
+var newAffix;
+function sliceNode(node, index, depth, pathLeft, pathRight, childLeft, childRight) {
+    var array = node.array.slice(pathLeft, pathRight + 1);
+    if (childLeft !== undefined) {
+        array[0] = childLeft;
+    }
+    if (childRight !== undefined) {
+        array[array.length - 1] = childRight;
+    }
+    var sizes = node.sizes;
+    if (sizes !== undefined) {
+        sizes = sizes.slice(pathLeft, pathRight + 1);
+        var slicedOffLeft = pathLeft !== 0 ? node.sizes[pathLeft - 1] : 0;
+        if (childLeft !== undefined) {
+            if (childLeft.sizes !== undefined) {
+                var oldChild = node.array[pathLeft];
+                slicedOffLeft +=
+                    arrayLast(oldChild.sizes) - arrayLast(childLeft.sizes);
+            }
+            else {
+                slicedOffLeft += ((index - slicedOffLeft) & ~31) + 32;
+            }
+        }
+        for (var i = 0; i < sizes.length; ++i) {
+            sizes[i] -= slicedOffLeft;
+        }
+        if (childRight !== undefined) {
+            var slicedOffRight = sizeOfSubtree(node.array[pathRight], depth - 1) -
+                sizeOfSubtree(childRight, depth - 1);
+            sizes[sizes.length - 1] -= slicedOffRight;
+        }
+    }
+    return new Node(sizes, array);
+}
+var newOffset = 0;
+function sliceLeft(tree, depth, index, offset, top) {
+    var _a = getPath(index, offset, depth, tree.sizes), path = _a.path, newIndex = _a.index, updatedOffset = _a.updatedOffset;
+    if (depth === 0) {
+        newAffix = tree.array.slice(path).reverse();
+        return undefined;
+    }
+    else {
+        var child = sliceLeft(tree.array[path], depth - 1, newIndex, updatedOffset, false);
+        if (child === undefined) {
+            ++path;
+            if (path === tree.array.length) {
+                return undefined;
+            }
+        }
+        if (tree.sizes === undefined && top === false) {
+            newOffset |= (32 - (tree.array.length - path)) << (depth * branchBits);
+        }
+        return sliceNode(tree, index, depth, path, tree.array.length - 1, child, undefined);
+    }
+}
+function sliceRight(node, depth, index, offset) {
+    var _a = getPath(index, offset, depth, node.sizes), path = _a.path, newIndex = _a.index;
+    if (depth === 0) {
+        newAffix = node.array.slice(0, path + 1);
+        return undefined;
+    }
+    else {
+        var child = sliceRight(node.array[path], depth - 1, newIndex, path === 0 ? offset : 0);
+        if (child === undefined) {
+            --path;
+            if (path === -1) {
+                return undefined;
+            }
+        }
+        var array = node.array.slice(0, path + 1);
+        if (child !== undefined) {
+            array[array.length - 1] = child;
+        }
+        var sizes = node.sizes;
+        if (sizes !== undefined) {
+            sizes = sizes.slice(0, path + 1);
+            if (child !== undefined) {
+                var slicedOff = sizeOfSubtree(node.array[path], depth - 1) -
+                    sizeOfSubtree(child, depth - 1);
+                sizes[sizes.length - 1] -= slicedOff;
+            }
+        }
+        return new Node(sizes, array);
+    }
+}
+function sliceTreeList(from, to, tree, depth, offset, l) {
+    var sizes = tree.sizes;
+    var _a = getPath(from, offset, depth, sizes), pathLeft = _a.path, newFrom = _a.index;
+    var _b = getPath(to, offset, depth, sizes), pathRight = _b.path, newTo = _b.index;
+    if (depth === 0) {
+        l.prefix = emptyAffix;
+        l.suffix = tree.array.slice(pathLeft, pathRight + 1);
+        l.root = undefined;
+        l.bits = setSuffix(pathRight - pathLeft + 1, 0);
+        return l;
+    }
+    else if (pathLeft === pathRight) {
+        l.bits = decrementDepth(l.bits);
+        return sliceTreeList(newFrom, newTo, tree.array[pathLeft], depth - 1, pathLeft === 0 ? offset : 0, l);
+    }
+    else {
+        var childRight = sliceRight(tree.array[pathRight], depth - 1, newTo, 0);
+        l.bits = setSuffix(newAffix.length, l.bits);
+        l.suffix = newAffix;
+        if (childRight === undefined) {
+            --pathRight;
+        }
+        newOffset = 0;
+        var childLeft = sliceLeft(tree.array[pathLeft], depth - 1, newFrom, pathLeft === 0 ? offset : 0, pathLeft === pathRight);
+        l.offset = newOffset;
+        l.bits = setPrefix(newAffix.length, l.bits);
+        l.prefix = newAffix;
+        if (childLeft === undefined) {
+            ++pathLeft;
+        }
+        if (pathLeft >= pathRight) {
+            if (pathLeft > pathRight) {
+                l.bits = setDepth(0, l.bits);
+                l.root = undefined;
+            }
+            else {
+                l.bits = decrementDepth(l.bits);
+                var newRoot = childRight !== undefined
+                    ? childRight
+                    : childLeft !== undefined
+                        ? childLeft
+                        : tree.array[pathLeft];
+                l.root = new Node(newRoot.sizes, newRoot.array);
+            }
+        }
+        else {
+            l.root = sliceNode(tree, from, depth, pathLeft, pathRight, childLeft, childRight);
+        }
+        return l;
+    }
+}
+export function slice(from, to, l) {
+    var bits = l.bits, length = l.length;
+    to = Math.min(length, to);
+    if (from < 0) {
+        from = length + from;
+    }
+    if (to < 0) {
+        to = length + to;
+    }
+    if (to <= from || to <= 0 || length <= from) {
+        return empty();
+    }
+    if (from <= 0 && length <= to) {
+        return l;
+    }
+    var newLength = to - from;
+    var prefixSize = getPrefixSize(l);
+    var suffixSize = getSuffixSize(l);
+    if (to <= prefixSize) {
+        return new List(setPrefix(newLength, 0), 0, newLength, l.prefix.slice(prefixSize - to, prefixSize - from), undefined, emptyAffix);
+    }
+    var suffixStart = length - suffixSize;
+    if (suffixStart <= from) {
+        return new List(setSuffix(newLength, 0), 0, newLength, emptyAffix, undefined, l.suffix.slice(from - suffixStart, to - suffixStart));
+    }
+    var newList = cloneList(l);
+    newList.length = newLength;
+    if (prefixSize <= from && to <= suffixStart) {
+        sliceTreeList(from - prefixSize + l.offset, to - prefixSize + l.offset - 1, l.root, getDepth(l), l.offset, newList);
+        return newList;
+    }
+    if (0 < from) {
+        if (from < prefixSize) {
+            newList.prefix = l.prefix.slice(0, prefixSize - from);
+            bits = setPrefix(prefixSize - from, bits);
+        }
+        else {
+            newOffset = 0;
+            newList.root = sliceLeft(newList.root, getDepth(l), from - prefixSize, l.offset, true);
+            newList.offset = newOffset;
+            if (newList.root === undefined) {
+                bits = setDepth(0, bits);
+            }
+            bits = setPrefix(newAffix.length, bits);
+            prefixSize = newAffix.length;
+            newList.prefix = newAffix;
+        }
+    }
+    if (to < length) {
+        if (length - to < suffixSize) {
+            bits = setSuffix(suffixSize - (length - to), bits);
+            newList.suffix = l.suffix.slice(0, suffixSize - (length - to));
+        }
+        else {
+            newList.root = sliceRight(newList.root, getDepth(l), to - prefixSize - 1, newList.offset);
+            if (newList.root === undefined) {
+                bits = setDepth(0, bits);
+                newList.offset = 0;
+            }
+            bits = setSuffix(newAffix.length, bits);
+            newList.suffix = newAffix;
+        }
+    }
+    newList.bits = bits;
+    return newList;
+}
+export function take(n, l) {
+    return slice(0, n, l);
+}
+function findNotIndexCb(value, state) {
+    if (state.predicate(value)) {
+        ++state.index;
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+export function takeWhile(predicate, l) {
+    var index = foldlCb(findNotIndexCb, { predicate: predicate, index: 0 }, l).index;
+    return slice(0, index, l);
+}
+export function takeLastWhile(predicate, l) {
+    var index = foldrCb(findNotIndexCb, { predicate: predicate, index: 0 }, l).index;
+    return slice(l.length - index, l.length, l);
+}
+export function dropWhile(predicate, l) {
+    var index = foldlCb(findNotIndexCb, { predicate: predicate, index: 0 }, l).index;
+    return slice(index, l.length, l);
+}
+export function dropRepeats(l) {
+    return dropRepeatsWith(elementEquals, l);
+}
+export function dropRepeatsWith(predicate, l) {
+    return foldl(function (acc, a) {
+        return acc.length !== 0 && predicate(last(acc), a) ? acc : push(a, acc);
+    }, emptyPushable(), l);
+}
+export function takeLast(n, l) {
+    return slice(l.length - n, l.length, l);
+}
+export function splitAt(index, l) {
+    return [slice(0, index, l), slice(index, l.length, l)];
+}
+export function splitWhen(predicate, l) {
+    var idx = findIndex(predicate, l);
+    return idx === -1 ? [l, empty()] : splitAt(idx, l);
+}
+export function splitEvery(size, l) {
+    var _a = foldl(function (_a, elm) {
+        var l2 = _a.l2, buffer = _a.buffer;
+        push(elm, buffer);
+        if (buffer.length === size) {
+            return { l2: push(buffer, l2), buffer: emptyPushable() };
+        }
+        else {
+            return { l2: l2, buffer: buffer };
+        }
+    }, { l2: emptyPushable(), buffer: emptyPushable() }, l), l2 = _a.l2, buffer = _a.buffer;
+    return buffer.length === 0 ? l2 : push(buffer, l2);
+}
+export function remove(from, amount, l) {
+    return concat(slice(0, from, l), slice(from + amount, l.length, l));
+}
+export function drop(n, l) {
+    return slice(n, l.length, l);
+}
+export function dropLast(n, l) {
+    return slice(0, l.length - n, l);
+}
+export function pop(l) {
+    return slice(0, -1, l);
+}
+export var init = pop;
+export function tail(l) {
+    return slice(1, l.length, l);
+}
+function arrayPush(array, a) {
+    array.push(a);
+    return array;
+}
+export function toArray(l) {
+    return foldl(arrayPush, [], l);
+}
+export function insert(index, element, l) {
+    return concat(append(element, slice(0, index, l)), slice(index, l.length, l));
+}
+export function insertAll(index, elements, l) {
+    return concat(concat(slice(0, index, l), elements), slice(index, l.length, l));
+}
+export function reverse(l) {
+    return foldl(function (newL, element) { return prepend(element, newL); }, empty(), l);
+}
+export function isList(l) {
+    return typeof l === "object" && Array.isArray(l.suffix);
+}
+export function zip(as, bs) {
+    return zipWith(function (a, b) { return [a, b]; }, as, bs);
+}
+export function zipWith(f, as, bs) {
+    var swapped = bs.length < as.length;
+    var iterator = (swapped ? as : bs)[Symbol.iterator]();
+    return map(function (a) {
+        var b = iterator.next().value;
+        return swapped ? f(b, a) : f(a, b);
+    }, (swapped ? bs : as));
+}
+function isPrimitive(value) {
+    return typeof value === "number" || typeof value === "string";
+}
+function comparePrimitive(a, b) {
+    return a === b ? 0 : a < b ? -1 : 1;
+}
+var ord = "fantasy-land/lte";
+function compareOrd(a, b) {
+    return a[ord](b) ? (b[ord](a) ? 0 : -1) : 1;
+}
+export function sort(l) {
+    if (l.length === 0) {
+        return l;
+    }
+    else if (isPrimitive(first(l))) {
+        return from(toArray(l).sort(comparePrimitive));
+    }
+    else {
+        return sortWith(compareOrd, l);
+    }
+}
+export function sortWith(comparator, l) {
+    var arr = [];
+    var i = 0;
+    forEach(function (elm) { return arr.push({ idx: i++, elm: elm }); }, l);
+    arr.sort(function (_a, _b) {
+        var a = _a.elm, i = _a.idx;
+        var b = _b.elm, j = _b.idx;
+        var c = comparator(a, b);
+        return c !== 0 ? c : i < j ? -1 : 1;
+    });
+    var newL = emptyPushable();
+    for (var i_3 = 0; i_3 < arr.length; ++i_3) {
+        push(arr[i_3].elm, newL);
+    }
+    return newL;
+}
+export function sortBy(f, l) {
+    if (l.length === 0) {
+        return l;
+    }
+    var arr = [];
+    var i = 0;
+    forEach(function (elm) { return arr.push({ idx: i++, elm: elm, prop: f(elm) }); }, l);
+    var comparator = isPrimitive(arr[0].prop)
+        ? comparePrimitive
+        : compareOrd;
+    arr.sort(function (_a, _b) {
+        var a = _a.prop, i = _a.idx;
+        var b = _b.prop, j = _b.idx;
+        var c = comparator(a, b);
+        return c !== 0 ? c : i < j ? -1 : 1;
+    });
+    var newL = emptyPushable();
+    for (var i_4 = 0; i_4 < arr.length; ++i_4) {
+        push(arr[i_4].elm, newL);
+    }
+    return newL;
+}
+export function group(l) {
+    return groupWith(elementEquals, l);
+}
+export function groupWith(f, l) {
+    var result = emptyPushable();
+    var buffer = emptyPushable();
+    forEach(function (a) {
+        if (buffer.length !== 0 && !f(last(buffer), a)) {
+            push(buffer, result);
+            buffer = emptyPushable();
+        }
+        push(a, buffer);
+    }, l);
+    return buffer.length === 0 ? result : push(buffer, result);
+}
+export function intersperse(separator, l) {
+    return pop(foldl(function (l2, a) { return push(separator, push(a, l2)); }, emptyPushable(), l));
+}
+export function isEmpty(l) {
+    return l.length === 0;
+}
diff --git a/node_modules/list/dist/es/methods.d.ts b/node_modules/list/dist/es/methods.d.ts
new file mode 100644
index 0000000..ce5e977
--- /dev/null
+++ b/node_modules/list/dist/es/methods.d.ts
@@ -0,0 +1,79 @@
+export * from "./index";
+declare module "./index" {
+    interface List<A> {
+        empty(): List<any>;
+        of<B>(b: B): List<B>;
+        append(value: A): List<A>;
+        nth(index: number): A | undefined;
+        prepend(value: A): List<A>;
+        append(value: A): List<A>;
+        intersperse(separator: A): List<A>;
+        first(): A | undefined;
+        head(): A | undefined;
+        last(): A | undefined;
+        map<B>(f: (a: A) => B): List<B>;
+        pluck<K extends keyof A>(key: K): List<A[K]>;
+        foldl<B>(f: (acc: B, value: A) => B, initial: B): B;
+        reduce<B>(f: (acc: B, value: A) => B, initial: B): B;
+        scan<B>(f: (acc: B, value: A) => B, initial: B): List<B>;
+        foldr<B>(f: (value: A, acc: B) => B, initial: B): B;
+        reduceRight<B>(f: (value: A, acc: B) => B, initial: B): B;
+        foldlWhile<B>(predicate: (acc: B, value: A) => boolean, f: (value: A, acc: B) => B, initial: B): B;
+        reduceWhile<B>(predicate: (acc: B, value: A) => boolean, f: (value: A, acc: B) => B, initial: B): B;
+        traverse<A, B>(of: Of, f: (a: A) => Applicative<B>): any;
+        sequence<A, B>(this: List<Applicative<A>>, of: Of): any;
+        forEach(callback: (a: A) => void): void;
+        filter(predicate: (a: A) => boolean): List<A>;
+        filter<B extends A>(predicate: (a: A) => a is B): List<B>;
+        reject(predicate: (a: A) => boolean): List<A>;
+        partition(predicate: (a: A) => boolean): [List<A>, List<A>];
+        join(separator: string): string;
+        ap<B>(listF: List<(a: A) => B>): List<B>;
+        flatten(this: List<List<A>>): List<A>;
+        flatMap<B>(f: (a: A) => List<B>): List<B>;
+        chain<B>(f: (a: A) => List<B>): List<B>;
+        every(predicate: (a: A) => boolean): boolean;
+        some(predicate: (a: A) => boolean): boolean;
+        none(predicate: (a: A) => boolean): boolean;
+        indexOf(element: A): number;
+        lastIndexOf(element: A): number;
+        find(predicate: (a: A) => boolean): A | undefined;
+        findLast(predicate: (a: A) => boolean): A | undefined;
+        findIndex(predicate: (a: A) => boolean): number;
+        includes(element: A): boolean;
+        equals(secondList: List<any>): boolean;
+        equalsWith(f: (a: A, b: A) => boolean, secondList: List<any>): boolean;
+        concat(right: List<A>): List<A>;
+        update(index: number, a: A): List<A>;
+        adjust(index: number, f: (a: A) => A): List<A>;
+        slice(from: number, to: number): List<A>;
+        take(n: number): List<A>;
+        takeWhile(predicate: (a: A) => boolean): List<A>;
+        takeLastWhile(predicate: (a: A) => boolean): List<A>;
+        takeLast(n: number): List<A>;
+        splitAt(index: number): [List<A>, List<A>];
+        splitWhen(predicate: (a: A) => boolean): [List<A>, List<A>];
+        splitEvery(size: number): List<List<A>>;
+        remove(from: number, amount: number): List<A>;
+        drop(n: number): List<A>;
+        dropWhile(predicate: (a: A) => boolean): List<A>;
+        dropRepeats(): List<A>;
+        dropRepeatsWith(predicate: (a: A, b: A) => boolean): List<A>;
+        dropLast(n: number): List<A>;
+        pop(): List<A>;
+        tail(): List<A>;
+        toArray(): A[];
+        insert(index: number, element: A): List<A>;
+        insertAll(index: number, elements: List<A>): List<A>;
+        reverse(): List<A>;
+        backwards(): Iterable<A>;
+        zipWith<B, C>(f: (a: A, b: B) => C, bs: List<B>): List<C>;
+        zip<B>(bs: List<B>): List<[A, B]>;
+        sort<A extends Comparable>(this: List<A>, l: List<A>): List<A>;
+        sortBy<B extends Comparable>(f: (a: A) => B): List<A>;
+        sortWith(comparator: (a: A, b: A) => Ordering): List<A>;
+        group(): List<List<A>>;
+        groupWith<A>(f: (a: A, b: A) => boolean): List<List<A>>;
+        isEmpty(): boolean;
+    }
+}
diff --git a/node_modules/list/dist/es/methods.js b/node_modules/list/dist/es/methods.js
new file mode 100644
index 0000000..b76b572
--- /dev/null
+++ b/node_modules/list/dist/es/methods.js
@@ -0,0 +1,212 @@
+import { List } from "./fantasy-land";
+import * as L from "./fantasy-land";
+export * from "./index";
+List.prototype.append = function (value) {
+    return L.append(value, this);
+};
+List.prototype.intersperse = function (separator) {
+    return L.intersperse(separator, this);
+};
+List.prototype.nth = function (index) {
+    return L.nth(index, this);
+};
+List.prototype.empty = function () {
+    return L.empty();
+};
+List.prototype.of = function (b) {
+    return L.of(b);
+};
+List.prototype.prepend = function (value) {
+    return L.prepend(value, this);
+};
+List.prototype.append = function (value) {
+    return L.append(value, this);
+};
+List.prototype.first = function () {
+    return L.first(this);
+};
+List.prototype.head = List.prototype.first;
+List.prototype.last = function () {
+    return L.last(this);
+};
+List.prototype.map = function (f) {
+    return L.map(f, this);
+};
+List.prototype.pluck = function (key) {
+    return L.pluck(key, this);
+};
+List.prototype.foldl = function foldl(f, initial) {
+    return L.foldl(f, initial, this);
+};
+List.prototype.reduce = List.prototype.foldl;
+List.prototype.scan = function scan(f, initial) {
+    return L.scan(f, initial, this);
+};
+List.prototype.foldr = function (f, initial) {
+    return L.foldr(f, initial, this);
+};
+List.prototype.reduceRight = List.prototype.foldr;
+List.prototype.foldlWhile = function foldlWhile(predicate, f, initial) {
+    return L.foldlWhile(predicate, f, initial, this);
+};
+List.prototype.reduceWhile = List.prototype.foldlWhile;
+List.prototype.traverse = function (of, f) {
+    return L.traverse(of, f, this);
+};
+List.prototype.sequence = function (of) {
+    return L.sequence(of, this);
+};
+List.prototype.forEach = function (callback) {
+    return L.forEach(callback, this);
+};
+List.prototype.filter = function (predicate) {
+    return L.filter(predicate, this);
+};
+List.prototype.reject = function (predicate) {
+    return L.reject(predicate, this);
+};
+List.prototype.partition = function (predicate) {
+    return L.partition(predicate, this);
+};
+List.prototype.join = function (separator) {
+    return L.join(separator, this);
+};
+List.prototype.ap = function (listF) {
+    return L.ap(listF, this);
+};
+List.prototype.flatten = function () {
+    return L.flatten(this);
+};
+List.prototype.flatMap = function (f) {
+    return L.flatMap(f, this);
+};
+List.prototype.chain = List.prototype.flatMap;
+List.prototype.every = function (predicate) {
+    return L.every(predicate, this);
+};
+List.prototype.some = function (predicate) {
+    return L.some(predicate, this);
+};
+List.prototype.none = function (predicate) {
+    return L.none(predicate, this);
+};
+List.prototype.indexOf = function (element) {
+    return L.indexOf(element, this);
+};
+List.prototype.lastIndexOf = function (element) {
+    return L.lastIndexOf(element, this);
+};
+List.prototype.find = function find(predicate) {
+    return L.find(predicate, this);
+};
+List.prototype.findLast = function findLast(predicate) {
+    return L.findLast(predicate, this);
+};
+List.prototype.findIndex = function (predicate) {
+    return L.findIndex(predicate, this);
+};
+List.prototype.includes = function (element) {
+    return L.includes(element, this);
+};
+List.prototype.equals = function (secondList) {
+    return L.equals(this, secondList);
+};
+List.prototype.equalsWith = function (f, secondList) {
+    return L.equalsWith(f, this, secondList);
+};
+List.prototype.concat = function (right) {
+    return L.concat(this, right);
+};
+List.prototype.update = function (index, a) {
+    return L.update(index, a, this);
+};
+List.prototype.adjust = function (index, f) {
+    return L.adjust(index, f, this);
+};
+List.prototype.slice = function (from, to) {
+    return L.slice(from, to, this);
+};
+List.prototype.take = function (n) {
+    return L.take(n, this);
+};
+List.prototype.takeWhile = function (predicate) {
+    return L.takeWhile(predicate, this);
+};
+List.prototype.takeLast = function (n) {
+    return L.takeLast(n, this);
+};
+List.prototype.takeLastWhile = function (predicate) {
+    return L.takeLastWhile(predicate, this);
+};
+List.prototype.splitAt = function (index) {
+    return L.splitAt(index, this);
+};
+List.prototype.splitWhen = function (predicate) {
+    return L.splitWhen(predicate, this);
+};
+List.prototype.splitEvery = function (size) {
+    return L.splitEvery(size, this);
+};
+List.prototype.remove = function (from, amount) {
+    return L.remove(from, amount, this);
+};
+List.prototype.drop = function (n) {
+    return L.drop(n, this);
+};
+List.prototype.dropWhile = function (predicate) {
+    return L.dropWhile(predicate, this);
+};
+List.prototype.dropRepeats = function () {
+    return L.dropRepeats(this);
+};
+List.prototype.dropRepeatsWith = function (predicate) {
+    return L.dropRepeatsWith(predicate, this);
+};
+List.prototype.dropLast = function (n) {
+    return L.dropLast(n, this);
+};
+List.prototype.pop = function () {
+    return L.pop(this);
+};
+List.prototype.tail = function () {
+    return L.tail(this);
+};
+List.prototype.toArray = function () {
+    return L.toArray(this);
+};
+List.prototype.insert = function (index, element) {
+    return L.insert(index, element, this);
+};
+List.prototype.insertAll = function (index, elements) {
+    return L.insertAll(index, elements, this);
+};
+List.prototype.reverse = function () {
+    return L.reverse(this);
+};
+List.prototype.backwards = function () {
+    return L.backwards(this);
+};
+List.prototype.zipWith = function (f, bs) {
+    return L.zipWith(f, this, bs);
+};
+List.prototype.zip = function (bs) {
+    return L.zip(this, bs);
+};
+List.prototype.sort = function () {
+    return L.sort(this);
+};
+List.prototype.sortWith = function (comparator) {
+    return L.sortWith(comparator, this);
+};
+List.prototype.sortBy = function (f) {
+    return L.sortBy(f, this);
+};
+List.prototype.group = function () {
+    return L.group(this);
+};
+List.prototype.groupWith = function (f) {
+    return L.groupWith(f, this);
+};
+List.prototype.isEmpty = function () {
+    return L.isEmpty(this);
+};
diff --git a/node_modules/list/dist/es/ramda.d.ts b/node_modules/list/dist/es/ramda.d.ts
new file mode 100644
index 0000000..76edcd4
--- /dev/null
+++ b/node_modules/list/dist/es/ramda.d.ts
@@ -0,0 +1,65 @@
+export { Node, List, list } from "./index";
+export declare const prepend: any;
+export declare const isList: any;
+export declare const append: any;
+export declare const of: any;
+export declare const pair: any;
+export declare const empty: any;
+export declare const repeat: any;
+export declare const times: any;
+export declare const length: any;
+export declare const first: any;
+export declare const head: any;
+export declare const last: any;
+export declare const nth: any;
+export declare const map: any;
+export declare const forEach: any;
+export declare const pluck: any;
+export declare const range: any;
+export declare const foldl: any;
+export declare const reduce: any;
+export declare const filter: any;
+export declare const reject: any;
+export declare const partition: any;
+export declare const join: any;
+export declare const foldr: any;
+export declare const reduceRight: any;
+export declare const ap: any;
+export declare const chain: any;
+export declare const flatten: any;
+export declare const every: any;
+export declare const all: any;
+export declare const some: any;
+export declare const any: any;
+export declare const none: any;
+export declare const find: any;
+export declare const indexOf: any;
+export declare const findIndex: any;
+export declare const includes: any;
+export declare const contains: any;
+export declare const equals: any;
+export declare const concat: any;
+export declare const update: any;
+export declare const adjust: any;
+export declare const slice: any;
+export declare const take: any;
+export declare const takeWhile: any;
+export declare const dropWhile: any;
+export declare const takeLast: any;
+export declare const splitAt: any;
+export declare const remove: any;
+export declare const reverse: any;
+export declare const drop: any;
+export declare const dropLast: any;
+export declare const pop: any;
+export declare const init: any;
+export declare const tail: any;
+export declare const toArray: any;
+export declare const from: any;
+export declare const insert: any;
+export declare const insertAll: any;
+export declare const zip: any;
+export declare const zipWith: any;
+export declare const sort: any;
+export declare const sortWith: any;
+export declare const sortBy: any;
diff --git a/node_modules/list/dist/es/ramda.js b/node_modules/list/dist/es/ramda.js
new file mode 100644
index 0000000..8fc37e6
--- /dev/null
+++ b/node_modules/list/dist/es/ramda.js
@@ -0,0 +1,67 @@
+import { curry } from "ramda";
+import * as L from "./index";
+export { Node, List, list } from "./index";
+export var prepend = curry(L.prepend);
+export var isList = curry(L.isList);
+export var append = curry(L.append);
+export var of = curry(L.of);
+export var pair = curry(L.pair);
+export var empty = curry(L.empty);
+export var repeat = curry(L.repeat);
+export var times = curry(L.times);
+export var length = curry(L.length);
+export var first = curry(L.first);
+export var head = first;
+export var last = curry(L.last);
+export var nth = curry(L.nth);
+export var map = curry(L.map);
+export var forEach = curry(L.forEach);
+export var pluck = curry(L.pluck);
+export var range = curry(L.range);
+export var foldl = curry(L.foldl);
+export var reduce = foldl;
+export var filter = curry(L.filter);
+export var reject = curry(L.reject);
+export var partition = curry(L.partition);
+export var join = curry(L.join);
+export var foldr = curry(L.foldr);
+export var reduceRight = foldr;
+export var ap = curry(L.ap);
+export var chain = curry(L.chain);
+export var flatten = curry(L.flatten);
+export var every = curry(L.every);
+export var all = every;
+export var some = curry(L.some);
+export var any = some;
+export var none = curry(L.none);
+export var find = curry(L.find);
+export var indexOf = curry(L.indexOf);
+export var findIndex = curry(L.findIndex);
+export var includes = curry(L.includes);
+export var contains = includes;
+export var equals = curry(L.equals);
+export var concat = curry(L.concat);
+export var update = curry(L.update);
+export var adjust = curry(L.adjust);
+export var slice = curry(L.slice);
+export var take = curry(L.take);
+export var takeWhile = curry(L.takeWhile);
+export var dropWhile = curry(L.dropWhile);
+export var takeLast = curry(L.takeLast);
+export var splitAt = curry(L.splitAt);
+export var remove = curry(L.remove);
+export var reverse = curry(L.reverse);
+export var drop = curry(L.drop);
+export var dropLast = curry(L.dropLast);
+export var pop = curry(L.pop);
+export var init = pop;
+export var tail = curry(L.tail);
+export var toArray = curry(L.toArray);
+export var from = curry(L.from);
+export var insert = curry(L.insert);
+export var insertAll = curry(L.insertAll);
+export var zip = curry(L.zip);
+export var zipWith = curry(L.zipWith);
+export var sort = curry(L.sort);
+export var sortWith = curry(L.sortWith);
+export var sortBy = curry(L.sortBy);
diff --git a/node_modules/list/dist/fantasy-land.d.ts b/node_modules/list/dist/fantasy-land.d.ts
new file mode 100644
index 0000000..03b44a5
--- /dev/null
+++ b/node_modules/list/dist/fantasy-land.d.ts
@@ -0,0 +1,15 @@
+export * from "./index";
+declare module "./index" {
+    interface List<A> {
+        "fantasy-land/equals"(l: List<A>): boolean;
+        "fantasy-land/map"<B>(f: (a: A) => B): List<B>;
+        "fantasy-land/of"<B>(b: B): List<B>;
+        "fantasy-land/ap"<B>(f: List<(a: A) => B>): List<B>;
+        "fantasy-land/chain"<B>(f: (a: A) => List<B>): List<B>;
+        "fantasy-land/filter"(predicate: (a: A) => boolean): List<A>;
+        "fantasy-land/empty"(): List<any>;
+        "fantasy-land/concat"(right: List<A>): List<A>;
+        "fantasy-land/reduce"<B>(f: (acc: B, value: A) => B, initial: B): B;
+        "fantasy-land/traverse"<A, B>(of: Of, f: (a: A) => Applicative<B>): any;
+    }
+}
diff --git a/node_modules/list/dist/fantasy-land.js b/node_modules/list/dist/fantasy-land.js
new file mode 100644
index 0000000..15265f5
--- /dev/null
+++ b/node_modules/list/dist/fantasy-land.js
@@ -0,0 +1,39 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+var index_1 = require("./index");
+__export(require("./index"));
+var flOf = "fantasy-land/of";
+var flEmpty = "fantasy-land/empty";
+index_1.List.prototype["fantasy-land/equals"] = function (l) {
+    return index_1.equals(this, l);
+};
+index_1.List.prototype["fantasy-land/map"] = function (f) {
+    return index_1.map(f, this);
+};
+index_1.List.prototype[flOf] = index_1.of;
+index_1.List[flOf] = index_1.List.prototype[flOf];
+index_1.List.prototype["fantasy-land/ap"] = function (listF) {
+    return index_1.ap(listF, this);
+};
+index_1.List.prototype["fantasy-land/chain"] = function (f) {
+    return index_1.chain(f, this);
+};
+index_1.List.prototype["fantasy-land/filter"] = function (predicate) {
+    return index_1.filter(predicate, this);
+};
+index_1.List.prototype[flEmpty] = function () {
+    return index_1.empty();
+};
+index_1.List[flEmpty] = index_1.List.prototype[flEmpty];
+index_1.List.prototype["fantasy-land/concat"] = function (right) {
+    return index_1.concat(this, right);
+};
+index_1.List.prototype["fantasy-land/reduce"] = function (f, initial) {
+    return index_1.foldl(f, initial, this);
+};
+index_1.List.prototype["fantasy-land/traverse"] = function (of, f) {
+    return index_1.traverse(of, f, this);
+};
diff --git a/node_modules/list/dist/index.d.ts b/node_modules/list/dist/index.d.ts
new file mode 100644
index 0000000..dd1f850
--- /dev/null
+++ b/node_modules/list/dist/index.d.ts
@@ -0,0 +1,115 @@
+export declare type Sizes = number[] | undefined;
+export declare class Node {
+    sizes: Sizes;
+    array: any[];
+    constructor(sizes: Sizes, array: any[]);
+}
+export declare class List<A> implements Iterable<A> {
+    readonly bits: number;
+    readonly offset: number;
+    readonly length: number;
+    readonly prefix: A[];
+    readonly root: Node | undefined;
+    readonly suffix: A[];
+    constructor(bits: number, offset: number, length: number, prefix: A[], root: Node | undefined, suffix: A[]);
+    [Symbol.iterator](): Iterator<A>;
+    toJSON(): A[];
+}
+export declare function backwards<A>(l: List<A>): Iterable<A>;
+export declare function list<A>(...elements: A[]): List<A>;
+export declare function empty<A = any>(): List<A>;
+export declare function of<A>(a: A): List<A>;
+export declare function pair<A>(first: A, second: A): List<A>;
+export declare function from<A>(sequence: A[] | ArrayLike<A> | Iterable<A>): List<A>;
+export declare function range(start: number, end: number): List<number>;
+export declare function repeat<A>(value: A, times: number): List<A>;
+export declare function times<A>(func: (index: number) => A, times: number): List<A>;
+export declare function nth<A>(index: number, l: List<A>): A | undefined;
+export declare function prepend<A>(value: A, l: List<A>): List<A>;
+export declare function append<A>(value: A, l: List<A>): List<A>;
+export declare function length(l: List<any>): number;
+export declare function first<A>(l: List<A>): A | undefined;
+export declare const head: typeof first;
+export declare function last<A>(l: List<A>): A | undefined;
+export declare function map<A, B>(f: (a: A) => B, l: List<A>): List<B>;
+export declare function pluck<A, K extends keyof A>(key: K, l: List<A>): List<A[K]>;
+export declare function foldl<A, B>(f: (acc: B, value: A) => B, initial: B, l: List<A>): B;
+export declare const reduce: typeof foldl;
+export interface Of {
+    "fantasy-land/of"<B>(a: B): Applicative<B>;
+}
+export interface Applicative<A> {
+    "fantasy-land/map"<B>(f: (a: A) => B): Applicative<B>;
+    "fantasy-land/ap"<B>(fa: Applicative<(a: A) => B>): Applicative<B>;
+}
+export declare function traverse<A, B>(of: Of, f: (a: A) => Applicative<B>, l: List<A>): any;
+export declare function sequence<A>(ofObj: Of, l: List<Applicative<A>>): any;
+export declare function scan<A, B>(f: (acc: B, value: A) => B, initial: B, l: List<A>): List<B>;
+export declare function forEach<A>(callback: (a: A) => void, l: List<A>): void;
+export declare function filter<A, B extends A>(predicate: (a: A) => a is B, l: List<A>): List<B>;
+export declare function filter<A>(predicate: (a: A) => boolean, l: List<A>): List<A>;
+export declare function reject<A>(predicate: (a: A) => boolean, l: List<A>): List<A>;
+export declare function partition<A, B extends A>(predicate: (a: A) => a is B, l: List<A>): [List<B>, List<Exclude<A, B>>];
+export declare function partition<A>(predicate: (a: A) => boolean, l: List<A>): [List<A>, List<A>];
+export declare function join(separator: string, l: List<string>): string;
+export declare function foldr<A, B>(f: (value: A, acc: B) => B, initial: B, l: List<A>): B;
+export declare const reduceRight: typeof foldr;
+export declare function ap<A, B>(listF: List<(a: A) => B>, l: List<A>): List<B>;
+export declare function flatten<A>(nested: List<List<A>>): List<A>;
+export declare function flatMap<A, B>(f: (a: A) => List<B>, l: List<A>): List<B>;
+export declare const chain: typeof flatMap;
+export declare function foldlWhile<A, B>(predicate: (acc: B, value: A) => boolean, f: (acc: B, value: A) => B, initial: B, l: List<A>): B;
+export declare const reduceWhile: typeof foldlWhile;
+export declare function every<A>(predicate: (a: A) => boolean, l: List<A>): boolean;
+export declare const all: typeof every;
+export declare function some<A>(predicate: (a: A) => boolean, l: List<A>): boolean;
+export declare const any: typeof some;
+export declare function none<A>(predicate: (a: A) => boolean, l: List<A>): boolean;
+export declare function find<A>(predicate: (a: A) => boolean, l: List<A>): A | undefined;
+export declare function findLast<A>(predicate: (a: A) => boolean, l: List<A>): A | undefined;
+export declare function indexOf<A>(element: A, l: List<A>): number;
+export declare function lastIndexOf<A>(element: A, l: List<A>): number;
+export declare function findIndex<A>(predicate: (a: A) => boolean, l: List<A>): number;
+export declare function includes<A>(element: A, l: List<A>): boolean;
+export declare const contains: typeof includes;
+export declare function equals<A>(l1: List<A>, l2: List<A>): boolean;
+export declare function equalsWith<A>(f: (a: A, b: A) => boolean, l1: List<A>, l2: List<A>): boolean;
+export declare function concat<A>(left: List<A>, right: List<A>): List<A>;
+export declare function update<A>(index: number, a: A, l: List<A>): List<A>;
+export declare function adjust<A>(index: number, f: (a: A) => A, l: List<A>): List<A>;
+export declare function slice<A>(from: number, to: number, l: List<A>): List<A>;
+export declare function take<A>(n: number, l: List<A>): List<A>;
+export declare function takeWhile<A>(predicate: (a: A) => boolean, l: List<A>): List<A>;
+export declare function takeLastWhile<A>(predicate: (a: A) => boolean, l: List<A>): List<A>;
+export declare function dropWhile<A>(predicate: (a: A) => boolean, l: List<A>): List<A>;
+export declare function dropRepeats<A>(l: List<A>): List<A>;
+export declare function dropRepeatsWith<A>(predicate: (a: A, b: A) => Boolean, l: List<A>): List<A>;
+export declare function takeLast<A>(n: number, l: List<A>): List<A>;
+export declare function splitAt<A>(index: number, l: List<A>): [List<A>, List<A>];
+export declare function splitWhen<A>(predicate: (a: A) => boolean, l: List<A>): [List<A>, List<A>];
+export declare function splitEvery<A>(size: number, l: List<A>): List<List<A>>;
+export declare function remove<A>(from: number, amount: number, l: List<A>): List<A>;
+export declare function drop<A>(n: number, l: List<A>): List<A>;
+export declare function dropLast<A>(n: number, l: List<A>): List<A>;
+export declare function pop<A>(l: List<A>): List<A>;
+export declare const init: typeof pop;
+export declare function tail<A>(l: List<A>): List<A>;
+export declare function toArray<A>(l: List<A>): A[];
+export declare function insert<A>(index: number, element: A, l: List<A>): List<A>;
+export declare function insertAll<A>(index: number, elements: List<A>, l: List<A>): List<A>;
+export declare function reverse<A>(l: List<A>): List<A>;
+export declare function isList<A>(l: any): l is List<A>;
+export declare function zip<A, B>(as: List<A>, bs: List<B>): List<[A, B]>;
+export declare function zipWith<A, B, C>(f: (a: A, b: B) => C, as: List<A>, bs: List<B>): List<C>;
+export declare type Ordering = -1 | 0 | 1;
+export interface Ord {
+    "fantasy-land/lte"(b: any): boolean;
+}
+export declare type Comparable = number | string | Ord;
+export declare function sort<A extends Comparable>(l: List<A>): List<A>;
+export declare function sortWith<A>(comparator: (a: A, b: A) => Ordering, l: List<A>): List<A>;
+export declare function sortBy<A, B extends Comparable>(f: (a: A) => B, l: List<A>): List<A>;
+export declare function group<A>(l: List<A>): List<List<A>>;
+export declare function groupWith<A>(f: (a: A, b: A) => boolean, l: List<A>): List<List<A>>;
+export declare function intersperse<A>(separator: A, l: List<A>): List<A>;
+export declare function isEmpty(l: List<any>): boolean;
diff --git a/node_modules/list/dist/index.js b/node_modules/list/dist/index.js
new file mode 100644
index 0000000..6a085dd
--- /dev/null
+++ b/node_modules/list/dist/index.js
@@ -0,0 +1,1704 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var branchingFactor = 32;
+var branchBits = 5;
+var mask = 31;
+function isSetoid(a) {
+    return a && typeof a["fantasy-land/equals"] === "function";
+}
+function elementEquals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    else if (isSetoid(a)) {
+        return a["fantasy-land/equals"](b);
+    }
+    else {
+        return false;
+    }
+}
+function createPath(depth, value) {
+    var current = value;
+    for (var i = 0; i < depth; ++i) {
+        current = new Node(undefined, [current]);
+    }
+    return current;
+}
+function copyArray(source) {
+    var array = [];
+    for (var i = 0; i < source.length; ++i) {
+        array[i] = source[i];
+    }
+    return array;
+}
+function pushElements(source, target, offset, amount) {
+    for (var i = offset; i < offset + amount; ++i) {
+        target.push(source[i]);
+    }
+}
+function copyIndices(source, sourceStart, target, targetStart, length) {
+    for (var i = 0; i < length; ++i) {
+        target[targetStart + i] = source[sourceStart + i];
+    }
+}
+function arrayPrepend(value, array) {
+    var newLength = array.length + 1;
+    var result = new Array(newLength);
+    result[0] = value;
+    for (var i = 1; i < newLength; ++i) {
+        result[i] = array[i - 1];
+    }
+    return result;
+}
+function reverseArray(array) {
+    return array.slice().reverse();
+}
+function arrayFirst(array) {
+    return array[0];
+}
+function arrayLast(array) {
+    return array[array.length - 1];
+}
+var pathResult = { path: 0, index: 0, updatedOffset: 0 };
+function getPath(index, offset, depth, sizes) {
+    if (sizes === undefined && offset !== 0) {
+        pathResult.updatedOffset = 0;
+        index = handleOffset(depth, offset, index);
+    }
+    var path = (index >> (depth * branchBits)) & mask;
+    if (sizes !== undefined) {
+        while (sizes[path] <= index) {
+            path++;
+        }
+        var traversed = path === 0 ? 0 : sizes[path - 1];
+        index -= traversed;
+        pathResult.updatedOffset = offset;
+    }
+    pathResult.path = path;
+    pathResult.index = index;
+    return pathResult;
+}
+function updateNode(node, depth, index, offset, value) {
+    var _a = getPath(index, offset, depth, node.sizes), path = _a.path, newIndex = _a.index, updatedOffset = _a.updatedOffset;
+    var array = copyArray(node.array);
+    array[path] =
+        depth > 0
+            ? updateNode(array[path], depth - 1, newIndex, updatedOffset, value)
+            : value;
+    return new Node(node.sizes, array);
+}
+var Node = (function () {
+    function Node(sizes, array) {
+        this.sizes = sizes;
+        this.array = array;
+    }
+    return Node;
+}());
+exports.Node = Node;
+function cloneNode(_a) {
+    var sizes = _a.sizes, array = _a.array;
+    return new Node(sizes === undefined ? undefined : copyArray(sizes), copyArray(array));
+}
+var emptyAffix = [0];
+var affixBits = 6;
+var affixMask = 63;
+function getSuffixSize(l) {
+    return l.bits & affixMask;
+}
+function getPrefixSize(l) {
+    return (l.bits >> affixBits) & affixMask;
+}
+function getDepth(l) {
+    return l.bits >> (affixBits * 2);
+}
+function setPrefix(size, bits) {
+    return (size << affixBits) | (bits & ~(affixMask << affixBits));
+}
+function setSuffix(size, bits) {
+    return size | (bits & ~affixMask);
+}
+function setDepth(depth, bits) {
+    return ((depth << (affixBits * 2)) | (bits & (affixMask | (affixMask << affixBits))));
+}
+function incrementPrefix(bits) {
+    return bits + (1 << affixBits);
+}
+function incrementSuffix(bits) {
+    return bits + 1;
+}
+function incrementDepth(bits) {
+    return bits + (1 << (affixBits * 2));
+}
+function decrementDepth(bits) {
+    return bits - (1 << (affixBits * 2));
+}
+var List = (function () {
+    function List(bits, offset, length, prefix, root, suffix) {
+        this.bits = bits;
+        this.offset = offset;
+        this.length = length;
+        this.prefix = prefix;
+        this.root = root;
+        this.suffix = suffix;
+    }
+    List.prototype[Symbol.iterator] = function () {
+        return new ForwardListIterator(this);
+    };
+    List.prototype.toJSON = function () {
+        return toArray(this);
+    };
+    return List;
+}());
+exports.List = List;
+function cloneList(l) {
+    return new List(l.bits, l.offset, l.length, l.prefix, l.root, l.suffix);
+}
+var ListIterator = (function () {
+    function ListIterator(l, direction) {
+        this.l = l;
+        this.result = { done: false, value: undefined };
+        this.idx = direction === 1 ? -1 : l.length;
+        this.prefixSize = getPrefixSize(l);
+        this.middleSize = l.length - getSuffixSize(l);
+        if (l.root !== undefined) {
+            var depth = getDepth(l);
+            this.stack = new Array(depth + 1);
+            this.indices = new Array(depth + 1);
+            var currentNode = l.root.array;
+            for (var i = depth; 0 <= i; --i) {
+                this.stack[i] = currentNode;
+                var idx = direction === 1 ? 0 : currentNode.length - 1;
+                this.indices[i] = idx;
+                currentNode = currentNode[idx].array;
+            }
+            this.indices[0] -= direction;
+        }
+    }
+    return ListIterator;
+}());
+var ForwardListIterator = (function (_super) {
+    __extends(ForwardListIterator, _super);
+    function ForwardListIterator(l) {
+        return _super.call(this, l, 1) || this;
+    }
+    ForwardListIterator.prototype.nextInTree = function () {
+        for (var i = 0; ++this.indices[i] === this.stack[i].length; ++i) {
+            this.indices[i] = 0;
+        }
+        for (; 0 < i; --i) {
+            this.stack[i - 1] = this.stack[i][this.indices[i]].array;
+        }
+    };
+    ForwardListIterator.prototype.next = function () {
+        var newVal;
+        var idx = ++this.idx;
+        if (idx < this.prefixSize) {
+            newVal = this.l.prefix[this.prefixSize - idx - 1];
+        }
+        else if (idx < this.middleSize) {
+            this.nextInTree();
+            newVal = this.stack[0][this.indices[0]];
+        }
+        else if (idx < this.l.length) {
+            newVal = this.l.suffix[idx - this.middleSize];
+        }
+        else {
+            this.result.done = true;
+        }
+        this.result.value = newVal;
+        return this.result;
+    };
+    return ForwardListIterator;
+}(ListIterator));
+var BackwardsListIterator = (function (_super) {
+    __extends(BackwardsListIterator, _super);
+    function BackwardsListIterator(l) {
+        return _super.call(this, l, -1) || this;
+    }
+    BackwardsListIterator.prototype.prevInTree = function () {
+        for (var i = 0; this.indices[i] === 0; ++i) { }
+        --this.indices[i];
+        for (; 0 < i; --i) {
+            var n = this.stack[i][this.indices[i]].array;
+            this.stack[i - 1] = n;
+            this.indices[i - 1] = n.length - 1;
+        }
+    };
+    BackwardsListIterator.prototype.next = function () {
+        var newVal;
+        var idx = --this.idx;
+        if (this.middleSize <= idx) {
+            newVal = this.l.suffix[idx - this.middleSize];
+        }
+        else if (this.prefixSize <= idx) {
+            this.prevInTree();
+            newVal = this.stack[0][this.indices[0]];
+        }
+        else if (0 <= idx) {
+            newVal = this.l.prefix[this.prefixSize - idx - 1];
+        }
+        else {
+            this.result.done = true;
+        }
+        this.result.value = newVal;
+        return this.result;
+    };
+    return BackwardsListIterator;
+}(ListIterator));
+function backwards(l) {
+    var _a;
+    return _a = {},
+        _a[Symbol.iterator] = function () {
+            return new BackwardsListIterator(l);
+        },
+        _a;
+}
+exports.backwards = backwards;
+function emptyPushable() {
+    return new List(0, 0, 0, [], undefined, []);
+}
+function push(value, l) {
+    var suffixSize = getSuffixSize(l);
+    if (l.length === 0) {
+        l.bits = setPrefix(1, l.bits);
+        l.prefix = [value];
+    }
+    else if (suffixSize < 32) {
+        l.bits = incrementSuffix(l.bits);
+        l.suffix.push(value);
+    }
+    else if (l.root === undefined) {
+        l.root = new Node(undefined, l.suffix);
+        l.suffix = [value];
+        l.bits = setSuffix(1, l.bits);
+    }
+    else {
+        var newNode = new Node(undefined, l.suffix);
+        var index = l.length - 1 - 32 + 1;
+        var current = l.root;
+        var depth = getDepth(l);
+        l.suffix = [value];
+        l.bits = setSuffix(1, l.bits);
+        if (index - 1 < Math.pow(branchingFactor, (depth + 1))) {
+            for (; depth >= 0; --depth) {
+                var path = (index >> (depth * branchBits)) & mask;
+                if (path < current.array.length) {
+                    current = current.array[path];
+                }
+                else {
+                    current.array.push(createPath(depth - 1, newNode));
+                    break;
+                }
+            }
+        }
+        else {
+            l.bits = incrementDepth(l.bits);
+            l.root = new Node(undefined, [l.root, createPath(depth, newNode)]);
+        }
+    }
+    l.length++;
+    return l;
+}
+function list() {
+    var elements = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        elements[_i] = arguments[_i];
+    }
+    var l = emptyPushable();
+    for (var _a = 0, elements_1 = elements; _a < elements_1.length; _a++) {
+        var element = elements_1[_a];
+        push(element, l);
+    }
+    return l;
+}
+exports.list = list;
+function empty() {
+    return new List(0, 0, 0, emptyAffix, undefined, emptyAffix);
+}
+exports.empty = empty;
+function of(a) {
+    return list(a);
+}
+exports.of = of;
+function pair(first, second) {
+    return new List(2, 0, 2, emptyAffix, undefined, [first, second]);
+}
+exports.pair = pair;
+function from(sequence) {
+    var l = emptyPushable();
+    if (sequence.length > 0 && (sequence[0] !== undefined || 0 in sequence)) {
+        for (var i = 0; i < sequence.length; ++i) {
+            push(sequence[i], l);
+        }
+    }
+    else if (Symbol.iterator in sequence) {
+        var iterator = sequence[Symbol.iterator]();
+        var cur = void 0;
+        while (!(cur = iterator.next()).done) {
+            push(cur.value, l);
+        }
+    }
+    return l;
+}
+exports.from = from;
+function range(start, end) {
+    var list = emptyPushable();
+    for (var i = start; i < end; ++i) {
+        push(i, list);
+    }
+    return list;
+}
+exports.range = range;
+function repeat(value, times) {
+    var l = emptyPushable();
+    while (--times >= 0) {
+        push(value, l);
+    }
+    return l;
+}
+exports.repeat = repeat;
+function times(func, times) {
+    var l = emptyPushable();
+    for (var i = 0; i < times; i++) {
+        push(func(i), l);
+    }
+    return l;
+}
+exports.times = times;
+function nodeNthDense(node, depth, index) {
+    var current = node;
+    for (; depth >= 0; --depth) {
+        current = current.array[(index >> (depth * branchBits)) & mask];
+    }
+    return current;
+}
+function handleOffset(depth, offset, index) {
+    index += offset;
+    for (; depth >= 0; --depth) {
+        index = index - (offset & (mask << (depth * branchBits)));
+        if (((index >> (depth * branchBits)) & mask) !== 0) {
+            break;
+        }
+    }
+    return index;
+}
+function nodeNth(node, depth, offset, index) {
+    var path;
+    var current = node;
+    while (current.sizes !== undefined) {
+        path = (index >> (depth * branchBits)) & mask;
+        while (current.sizes[path] <= index) {
+            path++;
+        }
+        if (path !== 0) {
+            index -= current.sizes[path - 1];
+            offset = 0;
+        }
+        depth--;
+        current = current.array[path];
+    }
+    return nodeNthDense(current, depth, offset === 0 ? index : handleOffset(depth, offset, index));
+}
+function nth(index, l) {
+    if (index < 0 || l.length <= index) {
+        return undefined;
+    }
+    var prefixSize = getPrefixSize(l);
+    var suffixSize = getSuffixSize(l);
+    if (index < prefixSize) {
+        return l.prefix[prefixSize - index - 1];
+    }
+    else if (index >= l.length - suffixSize) {
+        return l.suffix[index - (l.length - suffixSize)];
+    }
+    var offset = l.offset;
+    var depth = getDepth(l);
+    return l.root.sizes === undefined
+        ? nodeNthDense(l.root, depth, offset === 0
+            ? index - prefixSize
+            : handleOffset(depth, offset, index - prefixSize))
+        : nodeNth(l.root, depth, offset, index - prefixSize);
+}
+exports.nth = nth;
+function setSizes(node, height) {
+    var sum = 0;
+    var sizeTable = [];
+    for (var i = 0; i < node.array.length; ++i) {
+        sum += sizeOfSubtree(node.array[i], height - 1);
+        sizeTable[i] = sum;
+    }
+    node.sizes = sizeTable;
+    return node;
+}
+function sizeOfSubtree(node, height) {
+    if (height !== 0) {
+        if (node.sizes !== undefined) {
+            return arrayLast(node.sizes);
+        }
+        else {
+            var lastSize = sizeOfSubtree(arrayLast(node.array), height - 1);
+            return ((node.array.length - 1) << (height * branchBits)) + lastSize;
+        }
+    }
+    else {
+        return node.array.length;
+    }
+}
+function affixPush(a, array, length) {
+    if (array.length === length) {
+        array.push(a);
+        return array;
+    }
+    else {
+        var newArray = [];
+        copyIndices(array, 0, newArray, 0, length);
+        newArray.push(a);
+        return newArray;
+    }
+}
+function prepend(value, l) {
+    var prefixSize = getPrefixSize(l);
+    if (prefixSize < 32) {
+        return new List(incrementPrefix(l.bits), l.offset, l.length + 1, affixPush(value, l.prefix, prefixSize), l.root, l.suffix);
+    }
+    else {
+        var newList = cloneList(l);
+        prependNodeToTree(newList, reverseArray(l.prefix));
+        var newPrefix = [value];
+        newList.prefix = newPrefix;
+        newList.length++;
+        newList.bits = setPrefix(1, newList.bits);
+        return newList;
+    }
+}
+exports.prepend = prepend;
+function copyLeft(l, k) {
+    var currentNode = cloneNode(l.root);
+    l.root = currentNode;
+    for (var i = 1; i < k; ++i) {
+        var index = 0;
+        if (currentNode.sizes !== undefined) {
+            for (var i_1 = 0; i_1 < currentNode.sizes.length; ++i_1) {
+                currentNode.sizes[i_1] += 32;
+            }
+        }
+        var newNode = cloneNode(currentNode.array[index]);
+        currentNode.array[index] = newNode;
+        currentNode = newNode;
+    }
+    return currentNode;
+}
+function nodePrepend(value, size, node) {
+    var array = arrayPrepend(value, node.array);
+    var sizes = undefined;
+    if (node.sizes !== undefined) {
+        sizes = new Array(node.sizes.length + 1);
+        sizes[0] = size;
+        for (var i = 0; i < node.sizes.length; ++i) {
+            sizes[i + 1] = node.sizes[i] + size;
+        }
+    }
+    return new Node(sizes, array);
+}
+function prependTopTree(l, depth, node) {
+    var newOffset;
+    if (l.root.array.length < branchingFactor) {
+        newOffset = Math.pow(32, depth) - 32;
+        l.root = new Node(undefined, arrayPrepend(createPath(depth - 1, node), l.root.array));
+    }
+    else {
+        l.bits = incrementDepth(l.bits);
+        var sizes = l.root.sizes === undefined
+            ? undefined
+            : [32, arrayLast(l.root.sizes) + 32];
+        newOffset = depth === 0 ? 0 : Math.pow(32, (depth + 1)) - 32;
+        l.root = new Node(sizes, [createPath(depth, node), l.root]);
+    }
+    return newOffset;
+}
+function prependNodeToTree(l, array) {
+    if (l.root === undefined) {
+        if (getSuffixSize(l) === 0) {
+            l.bits = setSuffix(array.length, l.bits);
+            l.suffix = array;
+        }
+        else {
+            l.root = new Node(undefined, array);
+        }
+        return l;
+    }
+    else {
+        var node = new Node(undefined, array);
+        var depth = getDepth(l);
+        var newOffset_1 = 0;
+        if (l.root.sizes === undefined) {
+            if (l.offset !== 0) {
+                newOffset_1 = l.offset - branchingFactor;
+                l.root = prependDense(l.root, depth, l.offset, node);
+            }
+            else {
+                newOffset_1 = prependTopTree(l, depth, node);
+            }
+        }
+        else {
+            var copyableCount = 0;
+            var nodesTraversed = 0;
+            var currentNode = l.root;
+            while (currentNode.sizes !== undefined && nodesTraversed < depth) {
+                ++nodesTraversed;
+                if (currentNode.array.length < 32) {
+                    copyableCount = nodesTraversed;
+                }
+                currentNode = currentNode.array[0];
+            }
+            if (l.offset !== 0) {
+                var copiedNode = copyLeft(l, nodesTraversed);
+                for (var i = 0; i < copiedNode.sizes.length; ++i) {
+                    copiedNode.sizes[i] += branchingFactor;
+                }
+                copiedNode.array[0] = prependDense(copiedNode.array[0], depth - nodesTraversed, l.offset, node);
+                l.offset = l.offset - branchingFactor;
+                return l;
+            }
+            else {
+                if (copyableCount === 0) {
+                    l.offset = prependTopTree(l, depth, node);
+                }
+                else {
+                    var parent_1;
+                    var prependableNode = void 0;
+                    if (copyableCount > 1) {
+                        parent_1 = copyLeft(l, copyableCount - 1);
+                        prependableNode = parent_1.array[0];
+                    }
+                    else {
+                        parent_1 = undefined;
+                        prependableNode = l.root;
+                    }
+                    var path = createPath(depth - copyableCount, node);
+                    l.offset = Math.pow(32, (depth - copyableCount + 1)) - 32;
+                    var prepended = nodePrepend(path, 32, prependableNode);
+                    if (parent_1 === undefined) {
+                        l.root = prepended;
+                    }
+                    else {
+                        parent_1.array[0] = prepended;
+                    }
+                }
+                return l;
+            }
+        }
+        l.offset = newOffset_1;
+        return l;
+    }
+}
+function prependDense(node, depth, offset, value) {
+    var curOffset = (offset >> (depth * branchBits)) & mask;
+    var path = (((offset - 1) >> (depth * branchBits)) & mask) - curOffset;
+    if (path < 0) {
+        return new Node(undefined, arrayPrepend(createPath(depth - 1, value), node.array));
+    }
+    else {
+        var array = copyArray(node.array);
+        array[0] = prependDense(array[0], depth - 1, offset, value);
+        return new Node(undefined, array);
+    }
+}
+function append(value, l) {
+    var suffixSize = getSuffixSize(l);
+    if (suffixSize < 32) {
+        return new List(incrementSuffix(l.bits), l.offset, l.length + 1, l.prefix, l.root, affixPush(value, l.suffix, suffixSize));
+    }
+    var newSuffix = [value];
+    var newList = cloneList(l);
+    appendNodeToTree(newList, l.suffix);
+    newList.suffix = newSuffix;
+    newList.length++;
+    newList.bits = setSuffix(1, newList.bits);
+    return newList;
+}
+exports.append = append;
+function length(l) {
+    return l.length;
+}
+exports.length = length;
+function first(l) {
+    var prefixSize = getPrefixSize(l);
+    return prefixSize !== 0
+        ? l.prefix[prefixSize - 1]
+        : l.length !== 0
+            ? l.suffix[0]
+            : undefined;
+}
+exports.first = first;
+exports.head = first;
+function last(l) {
+    var suffixSize = getSuffixSize(l);
+    return suffixSize !== 0
+        ? l.suffix[suffixSize - 1]
+        : l.length !== 0
+            ? l.prefix[0]
+            : undefined;
+}
+exports.last = last;
+function mapArray(f, array) {
+    var result = new Array(array.length);
+    for (var i = 0; i < array.length; ++i) {
+        result[i] = f(array[i]);
+    }
+    return result;
+}
+function mapNode(f, node, depth) {
+    if (depth !== 0) {
+        var array = node.array;
+        var result = new Array(array.length);
+        for (var i = 0; i < array.length; ++i) {
+            result[i] = mapNode(f, array[i], depth - 1);
+        }
+        return new Node(node.sizes, result);
+    }
+    else {
+        return new Node(undefined, mapArray(f, node.array));
+    }
+}
+function mapPrefix(f, prefix, length) {
+    var newPrefix = new Array(length);
+    for (var i = length - 1; 0 <= i; --i) {
+        newPrefix[i] = f(prefix[i]);
+    }
+    return newPrefix;
+}
+function mapAffix(f, suffix, length) {
+    var newSuffix = new Array(length);
+    for (var i = 0; i < length; ++i) {
+        newSuffix[i] = f(suffix[i]);
+    }
+    return newSuffix;
+}
+function map(f, l) {
+    return new List(l.bits, l.offset, l.length, mapPrefix(f, l.prefix, getPrefixSize(l)), l.root === undefined ? undefined : mapNode(f, l.root, getDepth(l)), mapAffix(f, l.suffix, getSuffixSize(l)));
+}
+exports.map = map;
+function pluck(key, l) {
+    return map(function (a) { return a[key]; }, l);
+}
+exports.pluck = pluck;
+function foldlSuffix(f, acc, array, length) {
+    for (var i = 0; i < length; ++i) {
+        acc = f(acc, array[i]);
+    }
+    return acc;
+}
+function foldlPrefix(f, acc, array, length) {
+    for (var i = length - 1; 0 <= i; --i) {
+        acc = f(acc, array[i]);
+    }
+    return acc;
+}
+function foldlNode(f, acc, node, depth) {
+    var array = node.array;
+    if (depth === 0) {
+        return foldlSuffix(f, acc, array, array.length);
+    }
+    for (var i = 0; i < array.length; ++i) {
+        acc = foldlNode(f, acc, array[i], depth - 1);
+    }
+    return acc;
+}
+function foldl(f, initial, l) {
+    var suffixSize = getSuffixSize(l);
+    var prefixSize = getPrefixSize(l);
+    initial = foldlPrefix(f, initial, l.prefix, prefixSize);
+    if (l.root !== undefined) {
+        initial = foldlNode(f, initial, l.root, getDepth(l));
+    }
+    return foldlSuffix(f, initial, l.suffix, suffixSize);
+}
+exports.foldl = foldl;
+exports.reduce = foldl;
+function traverse(of, f, l) {
+    return foldr(function (a, fl) {
+        return fl["fantasy-land/ap"](f(a)["fantasy-land/map"](function (a) { return function (l) { return prepend(a, l); }; }));
+    }, of["fantasy-land/of"](empty()), l);
+}
+exports.traverse = traverse;
+function sequence(ofObj, l) {
+    return traverse(ofObj, function (a) { return a; }, l);
+}
+exports.sequence = sequence;
+function scan(f, initial, l) {
+    return foldl(function (l2, a) { return push(f(last(l2), a), l2); }, push(initial, emptyPushable()), l);
+}
+exports.scan = scan;
+function forEach(callback, l) {
+    foldl(function (_, element) { return callback(element); }, undefined, l);
+}
+exports.forEach = forEach;
+function filter(predicate, l) {
+    return foldl(function (acc, a) { return (predicate(a) ? push(a, acc) : acc); }, emptyPushable(), l);
+}
+exports.filter = filter;
+function reject(predicate, l) {
+    return foldl(function (acc, a) { return (predicate(a) ? acc : push(a, acc)); }, emptyPushable(), l);
+}
+exports.reject = reject;
+function partition(predicate, l) {
+    return foldl(function (arr, a) { return (predicate(a) ? push(a, arr[0]) : push(a, arr[1]), arr); }, [emptyPushable(), emptyPushable()], l);
+}
+exports.partition = partition;
+function join(separator, l) {
+    return foldl(function (a, b) { return (a.length === 0 ? b : a + separator + b); }, "", l);
+}
+exports.join = join;
+function foldrSuffix(f, initial, array, length) {
+    var acc = initial;
+    for (var i = length - 1; 0 <= i; --i) {
+        acc = f(array[i], acc);
+    }
+    return acc;
+}
+function foldrPrefix(f, initial, array, length) {
+    var acc = initial;
+    for (var i = 0; i < length; ++i) {
+        acc = f(array[i], acc);
+    }
+    return acc;
+}
+function foldrNode(f, initial, _a, depth) {
+    var array = _a.array;
+    if (depth === 0) {
+        return foldrSuffix(f, initial, array, array.length);
+    }
+    var acc = initial;
+    for (var i = array.length - 1; 0 <= i; --i) {
+        acc = foldrNode(f, acc, array[i], depth - 1);
+    }
+    return acc;
+}
+function foldr(f, initial, l) {
+    var suffixSize = getSuffixSize(l);
+    var prefixSize = getPrefixSize(l);
+    var acc = foldrSuffix(f, initial, l.suffix, suffixSize);
+    if (l.root !== undefined) {
+        acc = foldrNode(f, acc, l.root, getDepth(l));
+    }
+    return foldrPrefix(f, acc, l.prefix, prefixSize);
+}
+exports.foldr = foldr;
+exports.reduceRight = foldr;
+function ap(listF, l) {
+    return flatten(map(function (f) { return map(f, l); }, listF));
+}
+exports.ap = ap;
+function flatten(nested) {
+    return foldl(concat, empty(), nested);
+}
+exports.flatten = flatten;
+function flatMap(f, l) {
+    return flatten(map(f, l));
+}
+exports.flatMap = flatMap;
+exports.chain = flatMap;
+function foldlArrayCb(cb, state, array, from, to) {
+    for (var i = from; i < to && cb(array[i], state); ++i) { }
+    return i === to;
+}
+function foldrArrayCb(cb, state, array, from, to) {
+    for (var i = from - 1; to <= i && cb(array[i], state); --i) { }
+    return i === to - 1;
+}
+function foldlNodeCb(cb, state, node, depth) {
+    var array = node.array;
+    if (depth === 0) {
+        return foldlArrayCb(cb, state, array, 0, array.length);
+    }
+    var to = array.length;
+    for (var i = 0; i < to; ++i) {
+        if (!foldlNodeCb(cb, state, array[i], depth - 1)) {
+            return false;
+        }
+    }
+    return true;
+}
+function foldlCb(cb, state, l) {
+    var prefixSize = getPrefixSize(l);
+    if (!foldrArrayCb(cb, state, l.prefix, prefixSize, 0) ||
+        (l.root !== undefined && !foldlNodeCb(cb, state, l.root, getDepth(l)))) {
+        return state;
+    }
+    var suffixSize = getSuffixSize(l);
+    foldlArrayCb(cb, state, l.suffix, 0, suffixSize);
+    return state;
+}
+function foldrNodeCb(cb, state, node, depth) {
+    var array = node.array;
+    if (depth === 0) {
+        return foldrArrayCb(cb, state, array, array.length, 0);
+    }
+    for (var i = array.length - 1; 0 <= i; --i) {
+        if (!foldrNodeCb(cb, state, array[i], depth - 1)) {
+            return false;
+        }
+    }
+    return true;
+}
+function foldrCb(cb, state, l) {
+    var suffixSize = getSuffixSize(l);
+    var prefixSize = getPrefixSize(l);
+    if (!foldrArrayCb(cb, state, l.suffix, suffixSize, 0) ||
+        (l.root !== undefined && !foldrNodeCb(cb, state, l.root, getDepth(l)))) {
+        return state;
+    }
+    var prefix = l.prefix;
+    foldlArrayCb(cb, state, l.prefix, prefix.length - prefixSize, prefix.length);
+    return state;
+}
+function foldlWhileCb(a, state) {
+    if (state.predicate(state.result, a) === false) {
+        return false;
+    }
+    state.result = state.f(state.result, a);
+    return true;
+}
+function foldlWhile(predicate, f, initial, l) {
+    return foldlCb(foldlWhileCb, { predicate: predicate, f: f, result: initial }, l).result;
+}
+exports.foldlWhile = foldlWhile;
+exports.reduceWhile = foldlWhile;
+function everyCb(value, state) {
+    return (state.result = state.predicate(value));
+}
+function every(predicate, l) {
+    return foldlCb(everyCb, { predicate: predicate, result: true }, l).result;
+}
+exports.every = every;
+exports.all = every;
+function someCb(value, state) {
+    return !(state.result = state.predicate(value));
+}
+function some(predicate, l) {
+    return foldlCb(someCb, { predicate: predicate, result: false }, l).result;
+}
+exports.some = some;
+exports.any = some;
+function none(predicate, l) {
+    return !some(predicate, l);
+}
+exports.none = none;
+function findCb(value, state) {
+    if (state.predicate(value)) {
+        state.result = value;
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+function find(predicate, l) {
+    return foldlCb(findCb, { predicate: predicate, result: undefined }, l)
+        .result;
+}
+exports.find = find;
+function findLast(predicate, l) {
+    return foldrCb(findCb, { predicate: predicate, result: undefined }, l)
+        .result;
+}
+exports.findLast = findLast;
+function indexOfCb(value, state) {
+    ++state.index;
+    return !(state.found = elementEquals(value, state.element));
+}
+function indexOf(element, l) {
+    var state = { element: element, found: false, index: -1 };
+    foldlCb(indexOfCb, state, l);
+    return state.found ? state.index : -1;
+}
+exports.indexOf = indexOf;
+function lastIndexOf(element, l) {
+    var state = { element: element, found: false, index: 0 };
+    foldrCb(indexOfCb, state, l);
+    return state.found ? l.length - state.index : -1;
+}
+exports.lastIndexOf = lastIndexOf;
+function findIndexCb(value, state) {
+    ++state.index;
+    return !(state.found = state.predicate(value));
+}
+function findIndex(predicate, l) {
+    var _a = foldlCb(findIndexCb, { predicate: predicate, found: false, index: -1 }, l), found = _a.found, index = _a.index;
+    return found ? index : -1;
+}
+exports.findIndex = findIndex;
+var containsState = {
+    element: undefined,
+    result: false
+};
+function containsCb(value, state) {
+    return !(state.result = value === state.element);
+}
+function includes(element, l) {
+    containsState.element = element;
+    containsState.result = false;
+    return foldlCb(containsCb, containsState, l).result;
+}
+exports.includes = includes;
+exports.contains = includes;
+function equalsCb(value2, state) {
+    var value = state.iterator.next().value;
+    return (state.equals = state.f(value, value2));
+}
+function equals(l1, l2) {
+    return equalsWith(elementEquals, l1, l2);
+}
+exports.equals = equals;
+function equalsWith(f, l1, l2) {
+    if (l1 === l2) {
+        return true;
+    }
+    else if (l1.length !== l2.length) {
+        return false;
+    }
+    else {
+        var s = { iterator: l2[Symbol.iterator](), equals: true, f: f };
+        return foldlCb(equalsCb, s, l1).equals;
+    }
+}
+exports.equalsWith = equalsWith;
+var eMax = 2;
+function createConcatPlan(array) {
+    var sizes = [];
+    var sum = 0;
+    for (var i_2 = 0; i_2 < array.length; ++i_2) {
+        sum += array[i_2].array.length;
+        sizes[i_2] = array[i_2].array.length;
+    }
+    var optimalLength = Math.ceil(sum / branchingFactor);
+    var n = array.length;
+    var i = 0;
+    if (optimalLength + eMax >= n) {
+        return undefined;
+    }
+    while (optimalLength + eMax < n) {
+        while (sizes[i] > branchingFactor - eMax / 2) {
+            ++i;
+        }
+        var remaining = sizes[i];
+        do {
+            var size = Math.min(remaining + sizes[i + 1], branchingFactor);
+            sizes[i] = size;
+            remaining = remaining - (size - sizes[i + 1]);
+            ++i;
+        } while (remaining > 0);
+        for (var j = i; j <= n - 1; ++j) {
+            sizes[j] = sizes[j + 1];
+        }
+        --i;
+        --n;
+    }
+    sizes.length = n;
+    return sizes;
+}
+function concatNodeMerge(left, center, right) {
+    var array = [];
+    if (left !== undefined) {
+        for (var i = 0; i < left.array.length - 1; ++i) {
+            array.push(left.array[i]);
+        }
+    }
+    for (var i = 0; i < center.array.length; ++i) {
+        array.push(center.array[i]);
+    }
+    if (right !== undefined) {
+        for (var i = 1; i < right.array.length; ++i) {
+            array.push(right.array[i]);
+        }
+    }
+    return array;
+}
+function executeConcatPlan(merged, plan, height) {
+    var result = [];
+    var sourceIdx = 0;
+    var offset = 0;
+    for (var _i = 0, plan_1 = plan; _i < plan_1.length; _i++) {
+        var toMove = plan_1[_i];
+        var source = merged[sourceIdx].array;
+        if (toMove === source.length && offset === 0) {
+            result.push(merged[sourceIdx]);
+            ++sourceIdx;
+        }
+        else {
+            var node = new Node(undefined, []);
+            while (toMove > 0) {
+                var available = source.length - offset;
+                var itemsToCopy = Math.min(toMove, available);
+                pushElements(source, node.array, offset, itemsToCopy);
+                if (toMove >= available) {
+                    ++sourceIdx;
+                    source = merged[sourceIdx].array;
+                    offset = 0;
+                }
+                else {
+                    offset += itemsToCopy;
+                }
+                toMove -= itemsToCopy;
+            }
+            if (height > 1) {
+                setSizes(node, height - 1);
+            }
+            result.push(node);
+        }
+    }
+    return result;
+}
+function rebalance(left, center, right, height, top) {
+    var merged = concatNodeMerge(left, center, right);
+    var plan = createConcatPlan(merged);
+    var balanced = plan !== undefined ? executeConcatPlan(merged, plan, height) : merged;
+    if (balanced.length <= branchingFactor) {
+        if (top === true) {
+            return new Node(undefined, balanced);
+        }
+        else {
+            return new Node(undefined, [
+                setSizes(new Node(undefined, balanced), height)
+            ]);
+        }
+    }
+    else {
+        return new Node(undefined, [
+            setSizes(new Node(undefined, balanced.slice(0, branchingFactor)), height),
+            setSizes(new Node(undefined, balanced.slice(branchingFactor)), height)
+        ]);
+    }
+}
+function concatSubTree(left, lDepth, right, rDepth, isTop) {
+    if (lDepth > rDepth) {
+        var c = concatSubTree(arrayLast(left.array), lDepth - 1, right, rDepth, false);
+        return rebalance(left, c, undefined, lDepth, isTop);
+    }
+    else if (lDepth < rDepth) {
+        var c = concatSubTree(left, lDepth, arrayFirst(right.array), rDepth - 1, false);
+        return rebalance(undefined, c, right, rDepth, isTop);
+    }
+    else if (lDepth === 0) {
+        return new Node(undefined, [left, right]);
+    }
+    else {
+        var c = concatSubTree(arrayLast(left.array), lDepth - 1, arrayFirst(right.array), rDepth - 1, false);
+        return rebalance(left, c, right, lDepth, isTop);
+    }
+}
+function getHeight(node) {
+    if (node.array[0] instanceof Node) {
+        return 1 + getHeight(node.array[0]);
+    }
+    else {
+        return 0;
+    }
+}
+function appendNodeToTree(l, array) {
+    if (l.root === undefined) {
+        if (getPrefixSize(l) === 0) {
+            l.bits = setPrefix(array.length, l.bits);
+            l.prefix = reverseArray(array);
+        }
+        else {
+            l.root = new Node(undefined, array);
+        }
+        return l;
+    }
+    var depth = getDepth(l);
+    var index = handleOffset(depth, l.offset, l.length - 1 - getPrefixSize(l));
+    var nodesToCopy = 0;
+    var nodesVisited = 0;
+    var shift = depth * 5;
+    var currentNode = l.root;
+    if (Math.pow(32, (depth + 1)) < index) {
+        shift = 0;
+        nodesVisited = depth;
+    }
+    while (shift > 5) {
+        var childIndex = void 0;
+        if (currentNode.sizes === undefined) {
+            childIndex = (index >> shift) & mask;
+            index &= ~(mask << shift);
+        }
+        else {
+            childIndex = currentNode.array.length - 1;
+            index -= currentNode.sizes[childIndex - 1];
+        }
+        nodesVisited++;
+        if (childIndex < mask) {
+            nodesToCopy = nodesVisited;
+        }
+        currentNode = currentNode.array[childIndex];
+        if (currentNode === undefined) {
+            nodesToCopy = nodesVisited;
+            shift = 5;
+        }
+        shift -= 5;
+    }
+    if (shift !== 0) {
+        nodesVisited++;
+        if (currentNode.array.length < branchingFactor) {
+            nodesToCopy = nodesVisited;
+        }
+    }
+    var node = new Node(undefined, array);
+    if (nodesToCopy === 0) {
+        var newPath = nodesVisited === 0 ? node : createPath(nodesVisited, node);
+        var newRoot = new Node(undefined, [l.root, newPath]);
+        l.root = newRoot;
+        l.bits = incrementDepth(l.bits);
+    }
+    else {
+        var copiedNode = copyFirstK(l, nodesToCopy, array.length);
+        copiedNode.array.push(createPath(depth - nodesToCopy, node));
+    }
+    return l;
+}
+function copyFirstK(newList, k, leafSize) {
+    var currentNode = cloneNode(newList.root);
+    newList.root = currentNode;
+    for (var i = 1; i < k; ++i) {
+        var index = currentNode.array.length - 1;
+        if (currentNode.sizes !== undefined) {
+            currentNode.sizes[index] += leafSize;
+        }
+        var newNode = cloneNode(currentNode.array[index]);
+        currentNode.array[index] = newNode;
+        currentNode = newNode;
+    }
+    if (currentNode.sizes !== undefined) {
+        currentNode.sizes.push(arrayLast(currentNode.sizes) + leafSize);
+    }
+    return currentNode;
+}
+var concatBuffer = new Array(3);
+function concatAffixes(left, right) {
+    var nr = 0;
+    var arrIdx = 0;
+    var i = 0;
+    var length = getSuffixSize(left);
+    concatBuffer[nr] = [];
+    for (i = 0; i < length; ++i) {
+        concatBuffer[nr][arrIdx++] = left.suffix[i];
+    }
+    length = getPrefixSize(right);
+    for (i = 0; i < length; ++i) {
+        if (arrIdx === 32) {
+            arrIdx = 0;
+            ++nr;
+            concatBuffer[nr] = [];
+        }
+        concatBuffer[nr][arrIdx++] = right.prefix[length - 1 - i];
+    }
+    length = getSuffixSize(right);
+    for (i = 0; i < length; ++i) {
+        if (arrIdx === 32) {
+            arrIdx = 0;
+            ++nr;
+            concatBuffer[nr] = [];
+        }
+        concatBuffer[nr][arrIdx++] = right.suffix[i];
+    }
+    return nr;
+}
+function concat(left, right) {
+    if (left.length === 0) {
+        return right;
+    }
+    else if (right.length === 0) {
+        return left;
+    }
+    var newSize = left.length + right.length;
+    var rightSuffixSize = getSuffixSize(right);
+    var newList = cloneList(left);
+    if (right.root === undefined) {
+        var nrOfAffixes = concatAffixes(left, right);
+        for (var i = 0; i < nrOfAffixes; ++i) {
+            newList = appendNodeToTree(newList, concatBuffer[i]);
+            newList.length += concatBuffer[i].length;
+            concatBuffer[i] = undefined;
+        }
+        newList.length = newSize;
+        newList.suffix = concatBuffer[nrOfAffixes];
+        newList.bits = setSuffix(concatBuffer[nrOfAffixes].length, newList.bits);
+        concatBuffer[nrOfAffixes] = undefined;
+        return newList;
+    }
+    else {
+        var leftSuffixSize = getSuffixSize(left);
+        if (leftSuffixSize > 0) {
+            newList = appendNodeToTree(newList, left.suffix.slice(0, leftSuffixSize));
+            newList.length += leftSuffixSize;
+        }
+        newList = appendNodeToTree(newList, right.prefix.slice(0, getPrefixSize(right)).reverse());
+        var newNode = concatSubTree(newList.root, getDepth(newList), right.root, getDepth(right), true);
+        var newDepth = getHeight(newNode);
+        setSizes(newNode, newDepth);
+        newList.root = newNode;
+        newList.offset &= ~(mask << (getDepth(left) * branchBits));
+        newList.length = newSize;
+        newList.bits = setSuffix(rightSuffixSize, setDepth(newDepth, newList.bits));
+        newList.suffix = right.suffix;
+        return newList;
+    }
+}
+exports.concat = concat;
+function update(index, a, l) {
+    if (index < 0 || l.length <= index) {
+        return l;
+    }
+    var prefixSize = getPrefixSize(l);
+    var suffixSize = getSuffixSize(l);
+    var newList = cloneList(l);
+    if (index < prefixSize) {
+        var newPrefix = copyArray(newList.prefix);
+        newPrefix[newPrefix.length - index - 1] = a;
+        newList.prefix = newPrefix;
+    }
+    else if (index >= l.length - suffixSize) {
+        var newSuffix = copyArray(newList.suffix);
+        newSuffix[index - (l.length - suffixSize)] = a;
+        newList.suffix = newSuffix;
+    }
+    else {
+        newList.root = updateNode(l.root, getDepth(l), index - prefixSize, l.offset, a);
+    }
+    return newList;
+}
+exports.update = update;
+function adjust(index, f, l) {
+    if (index < 0 || l.length <= index) {
+        return l;
+    }
+    return update(index, f(nth(index, l)), l);
+}
+exports.adjust = adjust;
+var newAffix;
+function sliceNode(node, index, depth, pathLeft, pathRight, childLeft, childRight) {
+    var array = node.array.slice(pathLeft, pathRight + 1);
+    if (childLeft !== undefined) {
+        array[0] = childLeft;
+    }
+    if (childRight !== undefined) {
+        array[array.length - 1] = childRight;
+    }
+    var sizes = node.sizes;
+    if (sizes !== undefined) {
+        sizes = sizes.slice(pathLeft, pathRight + 1);
+        var slicedOffLeft = pathLeft !== 0 ? node.sizes[pathLeft - 1] : 0;
+        if (childLeft !== undefined) {
+            if (childLeft.sizes !== undefined) {
+                var oldChild = node.array[pathLeft];
+                slicedOffLeft +=
+                    arrayLast(oldChild.sizes) - arrayLast(childLeft.sizes);
+            }
+            else {
+                slicedOffLeft += ((index - slicedOffLeft) & ~31) + 32;
+            }
+        }
+        for (var i = 0; i < sizes.length; ++i) {
+            sizes[i] -= slicedOffLeft;
+        }
+        if (childRight !== undefined) {
+            var slicedOffRight = sizeOfSubtree(node.array[pathRight], depth - 1) -
+                sizeOfSubtree(childRight, depth - 1);
+            sizes[sizes.length - 1] -= slicedOffRight;
+        }
+    }
+    return new Node(sizes, array);
+}
+var newOffset = 0;
+function sliceLeft(tree, depth, index, offset, top) {
+    var _a = getPath(index, offset, depth, tree.sizes), path = _a.path, newIndex = _a.index, updatedOffset = _a.updatedOffset;
+    if (depth === 0) {
+        newAffix = tree.array.slice(path).reverse();
+        return undefined;
+    }
+    else {
+        var child = sliceLeft(tree.array[path], depth - 1, newIndex, updatedOffset, false);
+        if (child === undefined) {
+            ++path;
+            if (path === tree.array.length) {
+                return undefined;
+            }
+        }
+        if (tree.sizes === undefined && top === false) {
+            newOffset |= (32 - (tree.array.length - path)) << (depth * branchBits);
+        }
+        return sliceNode(tree, index, depth, path, tree.array.length - 1, child, undefined);
+    }
+}
+function sliceRight(node, depth, index, offset) {
+    var _a = getPath(index, offset, depth, node.sizes), path = _a.path, newIndex = _a.index;
+    if (depth === 0) {
+        newAffix = node.array.slice(0, path + 1);
+        return undefined;
+    }
+    else {
+        var child = sliceRight(node.array[path], depth - 1, newIndex, path === 0 ? offset : 0);
+        if (child === undefined) {
+            --path;
+            if (path === -1) {
+                return undefined;
+            }
+        }
+        var array = node.array.slice(0, path + 1);
+        if (child !== undefined) {
+            array[array.length - 1] = child;
+        }
+        var sizes = node.sizes;
+        if (sizes !== undefined) {
+            sizes = sizes.slice(0, path + 1);
+            if (child !== undefined) {
+                var slicedOff = sizeOfSubtree(node.array[path], depth - 1) -
+                    sizeOfSubtree(child, depth - 1);
+                sizes[sizes.length - 1] -= slicedOff;
+            }
+        }
+        return new Node(sizes, array);
+    }
+}
+function sliceTreeList(from, to, tree, depth, offset, l) {
+    var sizes = tree.sizes;
+    var _a = getPath(from, offset, depth, sizes), pathLeft = _a.path, newFrom = _a.index;
+    var _b = getPath(to, offset, depth, sizes), pathRight = _b.path, newTo = _b.index;
+    if (depth === 0) {
+        l.prefix = emptyAffix;
+        l.suffix = tree.array.slice(pathLeft, pathRight + 1);
+        l.root = undefined;
+        l.bits = setSuffix(pathRight - pathLeft + 1, 0);
+        return l;
+    }
+    else if (pathLeft === pathRight) {
+        l.bits = decrementDepth(l.bits);
+        return sliceTreeList(newFrom, newTo, tree.array[pathLeft], depth - 1, pathLeft === 0 ? offset : 0, l);
+    }
+    else {
+        var childRight = sliceRight(tree.array[pathRight], depth - 1, newTo, 0);
+        l.bits = setSuffix(newAffix.length, l.bits);
+        l.suffix = newAffix;
+        if (childRight === undefined) {
+            --pathRight;
+        }
+        newOffset = 0;
+        var childLeft = sliceLeft(tree.array[pathLeft], depth - 1, newFrom, pathLeft === 0 ? offset : 0, pathLeft === pathRight);
+        l.offset = newOffset;
+        l.bits = setPrefix(newAffix.length, l.bits);
+        l.prefix = newAffix;
+        if (childLeft === undefined) {
+            ++pathLeft;
+        }
+        if (pathLeft >= pathRight) {
+            if (pathLeft > pathRight) {
+                l.bits = setDepth(0, l.bits);
+                l.root = undefined;
+            }
+            else {
+                l.bits = decrementDepth(l.bits);
+                var newRoot = childRight !== undefined
+                    ? childRight
+                    : childLeft !== undefined
+                        ? childLeft
+                        : tree.array[pathLeft];
+                l.root = new Node(newRoot.sizes, newRoot.array);
+            }
+        }
+        else {
+            l.root = sliceNode(tree, from, depth, pathLeft, pathRight, childLeft, childRight);
+        }
+        return l;
+    }
+}
+function slice(from, to, l) {
+    var bits = l.bits, length = l.length;
+    to = Math.min(length, to);
+    if (from < 0) {
+        from = length + from;
+    }
+    if (to < 0) {
+        to = length + to;
+    }
+    if (to <= from || to <= 0 || length <= from) {
+        return empty();
+    }
+    if (from <= 0 && length <= to) {
+        return l;
+    }
+    var newLength = to - from;
+    var prefixSize = getPrefixSize(l);
+    var suffixSize = getSuffixSize(l);
+    if (to <= prefixSize) {
+        return new List(setPrefix(newLength, 0), 0, newLength, l.prefix.slice(prefixSize - to, prefixSize - from), undefined, emptyAffix);
+    }
+    var suffixStart = length - suffixSize;
+    if (suffixStart <= from) {
+        return new List(setSuffix(newLength, 0), 0, newLength, emptyAffix, undefined, l.suffix.slice(from - suffixStart, to - suffixStart));
+    }
+    var newList = cloneList(l);
+    newList.length = newLength;
+    if (prefixSize <= from && to <= suffixStart) {
+        sliceTreeList(from - prefixSize + l.offset, to - prefixSize + l.offset - 1, l.root, getDepth(l), l.offset, newList);
+        return newList;
+    }
+    if (0 < from) {
+        if (from < prefixSize) {
+            newList.prefix = l.prefix.slice(0, prefixSize - from);
+            bits = setPrefix(prefixSize - from, bits);
+        }
+        else {
+            newOffset = 0;
+            newList.root = sliceLeft(newList.root, getDepth(l), from - prefixSize, l.offset, true);
+            newList.offset = newOffset;
+            if (newList.root === undefined) {
+                bits = setDepth(0, bits);
+            }
+            bits = setPrefix(newAffix.length, bits);
+            prefixSize = newAffix.length;
+            newList.prefix = newAffix;
+        }
+    }
+    if (to < length) {
+        if (length - to < suffixSize) {
+            bits = setSuffix(suffixSize - (length - to), bits);
+            newList.suffix = l.suffix.slice(0, suffixSize - (length - to));
+        }
+        else {
+            newList.root = sliceRight(newList.root, getDepth(l), to - prefixSize - 1, newList.offset);
+            if (newList.root === undefined) {
+                bits = setDepth(0, bits);
+                newList.offset = 0;
+            }
+            bits = setSuffix(newAffix.length, bits);
+            newList.suffix = newAffix;
+        }
+    }
+    newList.bits = bits;
+    return newList;
+}
+exports.slice = slice;
+function take(n, l) {
+    return slice(0, n, l);
+}
+exports.take = take;
+function findNotIndexCb(value, state) {
+    if (state.predicate(value)) {
+        ++state.index;
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+function takeWhile(predicate, l) {
+    var index = foldlCb(findNotIndexCb, { predicate: predicate, index: 0 }, l).index;
+    return slice(0, index, l);
+}
+exports.takeWhile = takeWhile;
+function takeLastWhile(predicate, l) {
+    var index = foldrCb(findNotIndexCb, { predicate: predicate, index: 0 }, l).index;
+    return slice(l.length - index, l.length, l);
+}
+exports.takeLastWhile = takeLastWhile;
+function dropWhile(predicate, l) {
+    var index = foldlCb(findNotIndexCb, { predicate: predicate, index: 0 }, l).index;
+    return slice(index, l.length, l);
+}
+exports.dropWhile = dropWhile;
+function dropRepeats(l) {
+    return dropRepeatsWith(elementEquals, l);
+}
+exports.dropRepeats = dropRepeats;
+function dropRepeatsWith(predicate, l) {
+    return foldl(function (acc, a) {
+        return acc.length !== 0 && predicate(last(acc), a) ? acc : push(a, acc);
+    }, emptyPushable(), l);
+}
+exports.dropRepeatsWith = dropRepeatsWith;
+function takeLast(n, l) {
+    return slice(l.length - n, l.length, l);
+}
+exports.takeLast = takeLast;
+function splitAt(index, l) {
+    return [slice(0, index, l), slice(index, l.length, l)];
+}
+exports.splitAt = splitAt;
+function splitWhen(predicate, l) {
+    var idx = findIndex(predicate, l);
+    return idx === -1 ? [l, empty()] : splitAt(idx, l);
+}
+exports.splitWhen = splitWhen;
+function splitEvery(size, l) {
+    var _a = foldl(function (_a, elm) {
+        var l2 = _a.l2, buffer = _a.buffer;
+        push(elm, buffer);
+        if (buffer.length === size) {
+            return { l2: push(buffer, l2), buffer: emptyPushable() };
+        }
+        else {
+            return { l2: l2, buffer: buffer };
+        }
+    }, { l2: emptyPushable(), buffer: emptyPushable() }, l), l2 = _a.l2, buffer = _a.buffer;
+    return buffer.length === 0 ? l2 : push(buffer, l2);
+}
+exports.splitEvery = splitEvery;
+function remove(from, amount, l) {
+    return concat(slice(0, from, l), slice(from + amount, l.length, l));
+}
+exports.remove = remove;
+function drop(n, l) {
+    return slice(n, l.length, l);
+}
+exports.drop = drop;
+function dropLast(n, l) {
+    return slice(0, l.length - n, l);
+}
+exports.dropLast = dropLast;
+function pop(l) {
+    return slice(0, -1, l);
+}
+exports.pop = pop;
+exports.init = pop;
+function tail(l) {
+    return slice(1, l.length, l);
+}
+exports.tail = tail;
+function arrayPush(array, a) {
+    array.push(a);
+    return array;
+}
+function toArray(l) {
+    return foldl(arrayPush, [], l);
+}
+exports.toArray = toArray;
+function insert(index, element, l) {
+    return concat(append(element, slice(0, index, l)), slice(index, l.length, l));
+}
+exports.insert = insert;
+function insertAll(index, elements, l) {
+    return concat(concat(slice(0, index, l), elements), slice(index, l.length, l));
+}
+exports.insertAll = insertAll;
+function reverse(l) {
+    return foldl(function (newL, element) { return prepend(element, newL); }, empty(), l);
+}
+exports.reverse = reverse;
+function isList(l) {
+    return typeof l === "object" && Array.isArray(l.suffix);
+}
+exports.isList = isList;
+function zip(as, bs) {
+    return zipWith(function (a, b) { return [a, b]; }, as, bs);
+}
+exports.zip = zip;
+function zipWith(f, as, bs) {
+    var swapped = bs.length < as.length;
+    var iterator = (swapped ? as : bs)[Symbol.iterator]();
+    return map(function (a) {
+        var b = iterator.next().value;
+        return swapped ? f(b, a) : f(a, b);
+    }, (swapped ? bs : as));
+}
+exports.zipWith = zipWith;
+function isPrimitive(value) {
+    return typeof value === "number" || typeof value === "string";
+}
+function comparePrimitive(a, b) {
+    return a === b ? 0 : a < b ? -1 : 1;
+}
+var ord = "fantasy-land/lte";
+function compareOrd(a, b) {
+    return a[ord](b) ? (b[ord](a) ? 0 : -1) : 1;
+}
+function sort(l) {
+    if (l.length === 0) {
+        return l;
+    }
+    else if (isPrimitive(first(l))) {
+        return from(toArray(l).sort(comparePrimitive));
+    }
+    else {
+        return sortWith(compareOrd, l);
+    }
+}
+exports.sort = sort;
+function sortWith(comparator, l) {
+    var arr = [];
+    var i = 0;
+    forEach(function (elm) { return arr.push({ idx: i++, elm: elm }); }, l);
+    arr.sort(function (_a, _b) {
+        var a = _a.elm, i = _a.idx;
+        var b = _b.elm, j = _b.idx;
+        var c = comparator(a, b);
+        return c !== 0 ? c : i < j ? -1 : 1;
+    });
+    var newL = emptyPushable();
+    for (var i_3 = 0; i_3 < arr.length; ++i_3) {
+        push(arr[i_3].elm, newL);
+    }
+    return newL;
+}
+exports.sortWith = sortWith;
+function sortBy(f, l) {
+    if (l.length === 0) {
+        return l;
+    }
+    var arr = [];
+    var i = 0;
+    forEach(function (elm) { return arr.push({ idx: i++, elm: elm, prop: f(elm) }); }, l);
+    var comparator = isPrimitive(arr[0].prop)
+        ? comparePrimitive
+        : compareOrd;
+    arr.sort(function (_a, _b) {
+        var a = _a.prop, i = _a.idx;
+        var b = _b.prop, j = _b.idx;
+        var c = comparator(a, b);
+        return c !== 0 ? c : i < j ? -1 : 1;
+    });
+    var newL = emptyPushable();
+    for (var i_4 = 0; i_4 < arr.length; ++i_4) {
+        push(arr[i_4].elm, newL);
+    }
+    return newL;
+}
+exports.sortBy = sortBy;
+function group(l) {
+    return groupWith(elementEquals, l);
+}
+exports.group = group;
+function groupWith(f, l) {
+    var result = emptyPushable();
+    var buffer = emptyPushable();
+    forEach(function (a) {
+        if (buffer.length !== 0 && !f(last(buffer), a)) {
+            push(buffer, result);
+            buffer = emptyPushable();
+        }
+        push(a, buffer);
+    }, l);
+    return buffer.length === 0 ? result : push(buffer, result);
+}
+exports.groupWith = groupWith;
+function intersperse(separator, l) {
+    return pop(foldl(function (l2, a) { return push(separator, push(a, l2)); }, emptyPushable(), l));
+}
+exports.intersperse = intersperse;
+function isEmpty(l) {
+    return l.length === 0;
+}
+exports.isEmpty = isEmpty;
diff --git a/node_modules/list/dist/methods.d.ts b/node_modules/list/dist/methods.d.ts
new file mode 100644
index 0000000..ce5e977
--- /dev/null
+++ b/node_modules/list/dist/methods.d.ts
@@ -0,0 +1,79 @@
+export * from "./index";
+declare module "./index" {
+    interface List<A> {
+        empty(): List<any>;
+        of<B>(b: B): List<B>;
+        append(value: A): List<A>;
+        nth(index: number): A | undefined;
+        prepend(value: A): List<A>;
+        append(value: A): List<A>;
+        intersperse(separator: A): List<A>;
+        first(): A | undefined;
+        head(): A | undefined;
+        last(): A | undefined;
+        map<B>(f: (a: A) => B): List<B>;
+        pluck<K extends keyof A>(key: K): List<A[K]>;
+        foldl<B>(f: (acc: B, value: A) => B, initial: B): B;
+        reduce<B>(f: (acc: B, value: A) => B, initial: B): B;
+        scan<B>(f: (acc: B, value: A) => B, initial: B): List<B>;
+        foldr<B>(f: (value: A, acc: B) => B, initial: B): B;
+        reduceRight<B>(f: (value: A, acc: B) => B, initial: B): B;
+        foldlWhile<B>(predicate: (acc: B, value: A) => boolean, f: (value: A, acc: B) => B, initial: B): B;
+        reduceWhile<B>(predicate: (acc: B, value: A) => boolean, f: (value: A, acc: B) => B, initial: B): B;
+        traverse<A, B>(of: Of, f: (a: A) => Applicative<B>): any;
+        sequence<A, B>(this: List<Applicative<A>>, of: Of): any;
+        forEach(callback: (a: A) => void): void;
+        filter(predicate: (a: A) => boolean): List<A>;
+        filter<B extends A>(predicate: (a: A) => a is B): List<B>;
+        reject(predicate: (a: A) => boolean): List<A>;
+        partition(predicate: (a: A) => boolean): [List<A>, List<A>];
+        join(separator: string): string;
+        ap<B>(listF: List<(a: A) => B>): List<B>;
+        flatten(this: List<List<A>>): List<A>;
+        flatMap<B>(f: (a: A) => List<B>): List<B>;
+        chain<B>(f: (a: A) => List<B>): List<B>;
+        every(predicate: (a: A) => boolean): boolean;
+        some(predicate: (a: A) => boolean): boolean;
+        none(predicate: (a: A) => boolean): boolean;
+        indexOf(element: A): number;
+        lastIndexOf(element: A): number;
+        find(predicate: (a: A) => boolean): A | undefined;
+        findLast(predicate: (a: A) => boolean): A | undefined;
+        findIndex(predicate: (a: A) => boolean): number;
+        includes(element: A): boolean;
+        equals(secondList: List<any>): boolean;
+        equalsWith(f: (a: A, b: A) => boolean, secondList: List<any>): boolean;
+        concat(right: List<A>): List<A>;
+        update(index: number, a: A): List<A>;
+        adjust(index: number, f: (a: A) => A): List<A>;
+        slice(from: number, to: number): List<A>;
+        take(n: number): List<A>;
+        takeWhile(predicate: (a: A) => boolean): List<A>;
+        takeLastWhile(predicate: (a: A) => boolean): List<A>;
+        takeLast(n: number): List<A>;
+        splitAt(index: number): [List<A>, List<A>];
+        splitWhen(predicate: (a: A) => boolean): [List<A>, List<A>];
+        splitEvery(size: number): List<List<A>>;
+        remove(from: number, amount: number): List<A>;
+        drop(n: number): List<A>;
+        dropWhile(predicate: (a: A) => boolean): List<A>;
+        dropRepeats(): List<A>;
+        dropRepeatsWith(predicate: (a: A, b: A) => boolean): List<A>;
+        dropLast(n: number): List<A>;
+        pop(): List<A>;
+        tail(): List<A>;
+        toArray(): A[];
+        insert(index: number, element: A): List<A>;
+        insertAll(index: number, elements: List<A>): List<A>;
+        reverse(): List<A>;
+        backwards(): Iterable<A>;
+        zipWith<B, C>(f: (a: A, b: B) => C, bs: List<B>): List<C>;
+        zip<B>(bs: List<B>): List<[A, B]>;
+        sort<A extends Comparable>(this: List<A>, l: List<A>): List<A>;
+        sortBy<B extends Comparable>(f: (a: A) => B): List<A>;
+        sortWith(comparator: (a: A, b: A) => Ordering): List<A>;
+        group(): List<List<A>>;
+        groupWith<A>(f: (a: A, b: A) => boolean): List<List<A>>;
+        isEmpty(): boolean;
+    }
+}
diff --git a/node_modules/list/dist/methods.js b/node_modules/list/dist/methods.js
new file mode 100644
index 0000000..a2eb02d
--- /dev/null
+++ b/node_modules/list/dist/methods.js
@@ -0,0 +1,217 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+var fantasy_land_1 = require("./fantasy-land");
+var L = require("./fantasy-land");
+__export(require("./index"));
+fantasy_land_1.List.prototype.append = function (value) {
+    return L.append(value, this);
+};
+fantasy_land_1.List.prototype.intersperse = function (separator) {
+    return L.intersperse(separator, this);
+};
+fantasy_land_1.List.prototype.nth = function (index) {
+    return L.nth(index, this);
+};
+fantasy_land_1.List.prototype.empty = function () {
+    return L.empty();
+};
+fantasy_land_1.List.prototype.of = function (b) {
+    return L.of(b);
+};
+fantasy_land_1.List.prototype.prepend = function (value) {
+    return L.prepend(value, this);
+};
+fantasy_land_1.List.prototype.append = function (value) {
+    return L.append(value, this);
+};
+fantasy_land_1.List.prototype.first = function () {
+    return L.first(this);
+};
+fantasy_land_1.List.prototype.head = fantasy_land_1.List.prototype.first;
+fantasy_land_1.List.prototype.last = function () {
+    return L.last(this);
+};
+fantasy_land_1.List.prototype.map = function (f) {
+    return L.map(f, this);
+};
+fantasy_land_1.List.prototype.pluck = function (key) {
+    return L.pluck(key, this);
+};
+fantasy_land_1.List.prototype.foldl = function foldl(f, initial) {
+    return L.foldl(f, initial, this);
+};
+fantasy_land_1.List.prototype.reduce = fantasy_land_1.List.prototype.foldl;
+fantasy_land_1.List.prototype.scan = function scan(f, initial) {
+    return L.scan(f, initial, this);
+};
+fantasy_land_1.List.prototype.foldr = function (f, initial) {
+    return L.foldr(f, initial, this);
+};
+fantasy_land_1.List.prototype.reduceRight = fantasy_land_1.List.prototype.foldr;
+fantasy_land_1.List.prototype.foldlWhile = function foldlWhile(predicate, f, initial) {
+    return L.foldlWhile(predicate, f, initial, this);
+};
+fantasy_land_1.List.prototype.reduceWhile = fantasy_land_1.List.prototype.foldlWhile;
+fantasy_land_1.List.prototype.traverse = function (of, f) {
+    return L.traverse(of, f, this);
+};
+fantasy_land_1.List.prototype.sequence = function (of) {
+    return L.sequence(of, this);
+};
+fantasy_land_1.List.prototype.forEach = function (callback) {
+    return L.forEach(callback, this);
+};
+fantasy_land_1.List.prototype.filter = function (predicate) {
+    return L.filter(predicate, this);
+};
+fantasy_land_1.List.prototype.reject = function (predicate) {
+    return L.reject(predicate, this);
+};
+fantasy_land_1.List.prototype.partition = function (predicate) {
+    return L.partition(predicate, this);
+};
+fantasy_land_1.List.prototype.join = function (separator) {
+    return L.join(separator, this);
+};
+fantasy_land_1.List.prototype.ap = function (listF) {
+    return L.ap(listF, this);
+};
+fantasy_land_1.List.prototype.flatten = function () {
+    return L.flatten(this);
+};
+fantasy_land_1.List.prototype.flatMap = function (f) {
+    return L.flatMap(f, this);
+};
+fantasy_land_1.List.prototype.chain = fantasy_land_1.List.prototype.flatMap;
+fantasy_land_1.List.prototype.every = function (predicate) {
+    return L.every(predicate, this);
+};
+fantasy_land_1.List.prototype.some = function (predicate) {
+    return L.some(predicate, this);
+};
+fantasy_land_1.List.prototype.none = function (predicate) {
+    return L.none(predicate, this);
+};
+fantasy_land_1.List.prototype.indexOf = function (element) {
+    return L.indexOf(element, this);
+};
+fantasy_land_1.List.prototype.lastIndexOf = function (element) {
+    return L.lastIndexOf(element, this);
+};
+fantasy_land_1.List.prototype.find = function find(predicate) {
+    return L.find(predicate, this);
+};
+fantasy_land_1.List.prototype.findLast = function findLast(predicate) {
+    return L.findLast(predicate, this);
+};
+fantasy_land_1.List.prototype.findIndex = function (predicate) {
+    return L.findIndex(predicate, this);
+};
+fantasy_land_1.List.prototype.includes = function (element) {
+    return L.includes(element, this);
+};
+fantasy_land_1.List.prototype.equals = function (secondList) {
+    return L.equals(this, secondList);
+};
+fantasy_land_1.List.prototype.equalsWith = function (f, secondList) {
+    return L.equalsWith(f, this, secondList);
+};
+fantasy_land_1.List.prototype.concat = function (right) {
+    return L.concat(this, right);
+};
+fantasy_land_1.List.prototype.update = function (index, a) {
+    return L.update(index, a, this);
+};
+fantasy_land_1.List.prototype.adjust = function (index, f) {
+    return L.adjust(index, f, this);
+};
+fantasy_land_1.List.prototype.slice = function (from, to) {
+    return L.slice(from, to, this);
+};
+fantasy_land_1.List.prototype.take = function (n) {
+    return L.take(n, this);
+};
+fantasy_land_1.List.prototype.takeWhile = function (predicate) {
+    return L.takeWhile(predicate, this);
+};
+fantasy_land_1.List.prototype.takeLast = function (n) {
+    return L.takeLast(n, this);
+};
+fantasy_land_1.List.prototype.takeLastWhile = function (predicate) {
+    return L.takeLastWhile(predicate, this);
+};
+fantasy_land_1.List.prototype.splitAt = function (index) {
+    return L.splitAt(index, this);
+};
+fantasy_land_1.List.prototype.splitWhen = function (predicate) {
+    return L.splitWhen(predicate, this);
+};
+fantasy_land_1.List.prototype.splitEvery = function (size) {
+    return L.splitEvery(size, this);
+};
+fantasy_land_1.List.prototype.remove = function (from, amount) {
+    return L.remove(from, amount, this);
+};
+fantasy_land_1.List.prototype.drop = function (n) {
+    return L.drop(n, this);
+};
+fantasy_land_1.List.prototype.dropWhile = function (predicate) {
+    return L.dropWhile(predicate, this);
+};
+fantasy_land_1.List.prototype.dropRepeats = function () {
+    return L.dropRepeats(this);
+};
+fantasy_land_1.List.prototype.dropRepeatsWith = function (predicate) {
+    return L.dropRepeatsWith(predicate, this);
+};
+fantasy_land_1.List.prototype.dropLast = function (n) {
+    return L.dropLast(n, this);
+};
+fantasy_land_1.List.prototype.pop = function () {
+    return L.pop(this);
+};
+fantasy_land_1.List.prototype.tail = function () {
+    return L.tail(this);
+};
+fantasy_land_1.List.prototype.toArray = function () {
+    return L.toArray(this);
+};
+fantasy_land_1.List.prototype.insert = function (index, element) {
+    return L.insert(index, element, this);
+};
+fantasy_land_1.List.prototype.insertAll = function (index, elements) {
+    return L.insertAll(index, elements, this);
+};
+fantasy_land_1.List.prototype.reverse = function () {
+    return L.reverse(this);
+};
+fantasy_land_1.List.prototype.backwards = function () {
+    return L.backwards(this);
+};
+fantasy_land_1.List.prototype.zipWith = function (f, bs) {
+    return L.zipWith(f, this, bs);
+};
+fantasy_land_1.List.prototype.zip = function (bs) {
+    return L.zip(this, bs);
+};
+fantasy_land_1.List.prototype.sort = function () {
+    return L.sort(this);
+};
+fantasy_land_1.List.prototype.sortWith = function (comparator) {
+    return L.sortWith(comparator, this);
+};
+fantasy_land_1.List.prototype.sortBy = function (f) {
+    return L.sortBy(f, this);
+};
+fantasy_land_1.List.prototype.group = function () {
+    return L.group(this);
+};
+fantasy_land_1.List.prototype.groupWith = function (f) {
+    return L.groupWith(f, this);
+};
+fantasy_land_1.List.prototype.isEmpty = function () {
+    return L.isEmpty(this);
+};
diff --git a/node_modules/list/dist/ramda.d.ts b/node_modules/list/dist/ramda.d.ts
new file mode 100644
index 0000000..831faaf
--- /dev/null
+++ b/node_modules/list/dist/ramda.d.ts
@@ -0,0 +1,66 @@
+import * as L from "./index";
+export { Node, List, list } from "./index";
+export declare const prepend: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(value: any, l: L.List<any>) => L.List<any>>;
+export declare const isList: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(l: any) => l is L.List<unknown>>;
+export declare const append: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(value: any, l: L.List<any>) => L.List<any>>;
+export declare const of: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(a: any) => L.List<any>>;
+export declare const pair: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(first: any, second: any) => L.List<any>>;
+export declare const empty: import("ts-toolbelt/out/types/src/Function/Curry").Curry<() => L.List<any>>;
+export declare const repeat: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(value: any, times: number) => L.List<any>>;
+export declare const times: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(func: (index: number) => unknown, times: number) => L.List<unknown>>;
+export declare const length: import("ts-toolbelt/out/types/src/Function/Curry").Curry<typeof L.length>;
+export declare const first: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(l: L.List<unknown>) => unknown>;
+export declare const head: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(l: L.List<unknown>) => unknown>;
+export declare const last: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(l: L.List<unknown>) => unknown>;
+export declare const nth: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(index: number, l: L.List<unknown>) => unknown>;
+export declare const map: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(f: (a: unknown) => unknown, l: L.List<unknown>) => L.List<unknown>>;
+export declare const forEach: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(callback: (a: unknown) => void, l: L.List<unknown>) => void>;
+export declare const pluck: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(key: string, l: L.List<unknown>) => unknown>;
+export declare const range: import("ts-toolbelt/out/types/src/Function/Curry").Curry<typeof L.range>;
+export declare const foldl: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(f: (acc: any, value: unknown) => any, initial: any, l: L.List<unknown>) => any>;
+export declare const reduce: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(f: (acc: any, value: unknown) => any, initial: any, l: L.List<unknown>) => any>;
+export declare const filter: import("ts-toolbelt/out/types/src/Function/Curry").Curry<typeof L.filter>;
+export declare const reject: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(predicate: (a: unknown) => boolean, l: L.List<unknown>) => L.List<unknown>>;
+export declare const partition: import("ts-toolbelt/out/types/src/Function/Curry").Curry<typeof L.partition>;
+export declare const join: import("ts-toolbelt/out/types/src/Function/Curry").Curry<typeof L.join>;
+export declare const foldr: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(f: (value: unknown, acc: any) => any, initial: any, l: L.List<unknown>) => any>;
+export declare const reduceRight: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(f: (value: unknown, acc: any) => any, initial: any, l: L.List<unknown>) => any>;
+export declare const ap: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(listF: L.List<(a: unknown) => unknown>, l: L.List<unknown>) => L.List<unknown>>;
+export declare const chain: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(f: (a: unknown) => L.List<unknown>, l: L.List<unknown>) => L.List<unknown>>;
+export declare const flatten: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(nested: L.List<L.List<unknown>>) => L.List<unknown>>;
+export declare const every: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(predicate: (a: unknown) => boolean, l: L.List<unknown>) => boolean>;
+export declare const all: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(predicate: (a: unknown) => boolean, l: L.List<unknown>) => boolean>;
+export declare const some: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(predicate: (a: unknown) => boolean, l: L.List<unknown>) => boolean>;
+export declare const any: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(predicate: (a: unknown) => boolean, l: L.List<unknown>) => boolean>;
+export declare const none: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(predicate: (a: unknown) => boolean, l: L.List<unknown>) => boolean>;
+export declare const find: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(predicate: (a: unknown) => boolean, l: L.List<unknown>) => unknown>;
+export declare const indexOf: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(element: any, l: L.List<any>) => number>;
+export declare const findIndex: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(predicate: (a: unknown) => boolean, l: L.List<unknown>) => number>;
+export declare const includes: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(element: any, l: L.List<any>) => boolean>;
+export declare const contains: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(element: any, l: L.List<any>) => boolean>;
+export declare const equals: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(l1: L.List<unknown>, l2: L.List<unknown>) => boolean>;
+export declare const concat: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(left: L.List<unknown>, right: L.List<unknown>) => L.List<unknown>>;
+export declare const update: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(index: number, a: any, l: L.List<any>) => L.List<any>>;
+export declare const adjust: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(index: number, f: (a: unknown) => unknown, l: L.List<unknown>) => L.List<unknown>>;
+export declare const slice: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(from: number, to: number, l: L.List<unknown>) => L.List<unknown>>;
+export declare const take: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(n: number, l: L.List<unknown>) => L.List<unknown>>;
+export declare const takeWhile: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(predicate: (a: unknown) => boolean, l: L.List<unknown>) => L.List<unknown>>;
+export declare const dropWhile: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(predicate: (a: unknown) => boolean, l: L.List<unknown>) => L.List<unknown>>;
+export declare const takeLast: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(n: number, l: L.List<unknown>) => L.List<unknown>>;
+export declare const splitAt: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(index: number, l: L.List<unknown>) => [L.List<unknown>, L.List<unknown>]>;
+export declare const remove: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(from: number, amount: number, l: L.List<unknown>) => L.List<unknown>>;
+export declare const reverse: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(l: L.List<unknown>) => L.List<unknown>>;
+export declare const drop: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(n: number, l: L.List<unknown>) => L.List<unknown>>;
+export declare const dropLast: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(n: number, l: L.List<unknown>) => L.List<unknown>>;
+export declare const pop: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(l: L.List<unknown>) => L.List<unknown>>;
+export declare const init: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(l: L.List<unknown>) => L.List<unknown>>;
+export declare const tail: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(l: L.List<unknown>) => L.List<unknown>>;
+export declare const toArray: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(l: L.List<unknown>) => unknown[]>;
+export declare const from: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(sequence: unknown[] | ArrayLike<unknown> | Iterable<unknown>) => L.List<unknown>>;
+export declare const insert: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(index: number, element: any, l: L.List<any>) => L.List<any>>;
+export declare const insertAll: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(index: number, elements: L.List<unknown>, l: L.List<unknown>) => L.List<unknown>>;
+export declare const zip: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(as: L.List<unknown>, bs: L.List<unknown>) => L.List<[unknown, unknown]>>;
+export declare const zipWith: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(f: (a: unknown, b: unknown) => unknown, as: L.List<unknown>, bs: L.List<unknown>) => L.List<unknown>>;
+export declare const sort: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(l: L.List<L.Comparable>) => L.List<L.Comparable>>;
+export declare const sortWith: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(comparator: (a: unknown, b: unknown) => L.Ordering, l: L.List<unknown>) => L.List<unknown>>;
+export declare const sortBy: import("ts-toolbelt/out/types/src/Function/Curry").Curry<(f: (a: unknown) => L.Comparable, l: L.List<unknown>) => L.List<unknown>>;
diff --git a/node_modules/list/dist/ramda.js b/node_modules/list/dist/ramda.js
new file mode 100644
index 0000000..8973a6e
--- /dev/null
+++ b/node_modules/list/dist/ramda.js
@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ramda_1 = require("ramda");
+var L = require("./index");
+var index_1 = require("./index");
+exports.Node = index_1.Node;
+exports.List = index_1.List;
+exports.list = index_1.list;
+exports.prepend = ramda_1.curry(L.prepend);
+exports.isList = ramda_1.curry(L.isList);
+exports.append = ramda_1.curry(L.append);
+exports.of = ramda_1.curry(L.of);
+exports.pair = ramda_1.curry(L.pair);
+exports.empty = ramda_1.curry(L.empty);
+exports.repeat = ramda_1.curry(L.repeat);
+exports.times = ramda_1.curry(L.times);
+exports.length = ramda_1.curry(L.length);
+exports.first = ramda_1.curry(L.first);
+exports.head = exports.first;
+exports.last = ramda_1.curry(L.last);
+exports.nth = ramda_1.curry(L.nth);
+exports.map = ramda_1.curry(L.map);
+exports.forEach = ramda_1.curry(L.forEach);
+exports.pluck = ramda_1.curry(L.pluck);
+exports.range = ramda_1.curry(L.range);
+exports.foldl = ramda_1.curry(L.foldl);
+exports.reduce = exports.foldl;
+exports.filter = ramda_1.curry(L.filter);
+exports.reject = ramda_1.curry(L.reject);
+exports.partition = ramda_1.curry(L.partition);
+exports.join = ramda_1.curry(L.join);
+exports.foldr = ramda_1.curry(L.foldr);
+exports.reduceRight = exports.foldr;
+exports.ap = ramda_1.curry(L.ap);
+exports.chain = ramda_1.curry(L.chain);
+exports.flatten = ramda_1.curry(L.flatten);
+exports.every = ramda_1.curry(L.every);
+exports.all = exports.every;
+exports.some = ramda_1.curry(L.some);
+exports.any = exports.some;
+exports.none = ramda_1.curry(L.none);
+exports.find = ramda_1.curry(L.find);
+exports.indexOf = ramda_1.curry(L.indexOf);
+exports.findIndex = ramda_1.curry(L.findIndex);
+exports.includes = ramda_1.curry(L.includes);
+exports.contains = exports.includes;
+exports.equals = ramda_1.curry(L.equals);
+exports.concat = ramda_1.curry(L.concat);
+exports.update = ramda_1.curry(L.update);
+exports.adjust = ramda_1.curry(L.adjust);
+exports.slice = ramda_1.curry(L.slice);
+exports.take = ramda_1.curry(L.take);
+exports.takeWhile = ramda_1.curry(L.takeWhile);
+exports.dropWhile = ramda_1.curry(L.dropWhile);
+exports.takeLast = ramda_1.curry(L.takeLast);
+exports.splitAt = ramda_1.curry(L.splitAt);
+exports.remove = ramda_1.curry(L.remove);
+exports.reverse = ramda_1.curry(L.reverse);
+exports.drop = ramda_1.curry(L.drop);
+exports.dropLast = ramda_1.curry(L.dropLast);
+exports.pop = ramda_1.curry(L.pop);
+exports.init = exports.pop;
+exports.tail = ramda_1.curry(L.tail);
+exports.toArray = ramda_1.curry(L.toArray);
+exports.from = ramda_1.curry(L.from);
+exports.insert = ramda_1.curry(L.insert);
+exports.insertAll = ramda_1.curry(L.insertAll);
+exports.zip = ramda_1.curry(L.zip);
+exports.zipWith = ramda_1.curry(L.zipWith);
+exports.sort = ramda_1.curry(L.sort);
+exports.sortWith = ramda_1.curry(L.sortWith);
+exports.sortBy = ramda_1.curry(L.sortBy);
diff --git a/node_modules/list/fantasy-land/package.json b/node_modules/list/fantasy-land/package.json
new file mode 100644
index 0000000..af606b0
--- /dev/null
+++ b/node_modules/list/fantasy-land/package.json
@@ -0,0 +1,7 @@
+{
+  "name": "list/fantasy-land",
+  "private": true,
+  "main": "../dist/fantasy-land.js",
+  "module": "../dist/es/fantasy-land.js",
+  "types": "../dist/fantasy-land.d.ts"
+}
diff --git a/node_modules/list/methods/package.json b/node_modules/list/methods/package.json
new file mode 100644
index 0000000..df712ae
--- /dev/null
+++ b/node_modules/list/methods/package.json
@@ -0,0 +1,7 @@
+{
+  "name": "list/methods",
+  "private": true,
+  "main": "../dist/methods.js",
+  "module": "../dist/es/methods.js",
+  "types": "../dist/methods.d.ts"
+}
diff --git a/node_modules/list/package.json b/node_modules/list/package.json
new file mode 100644
index 0000000..014ed84
--- /dev/null
+++ b/node_modules/list/package.json
@@ -0,0 +1,92 @@
+{
+  "name": "list",
+  "version": "2.0.19",
+  "description": "Fast purely functional immutable lists.",
+  "author": "Simon Friis Vindum",
+  "license": "MIT",
+  "repository": "github:funkia/list",
+  "keywords": [
+    "immutable",
+    "list",
+    "functional",
+    "persistent",
+    "sequence",
+    "vector"
+  ],
+  "bugs": {
+    "url": "https://github.com/funkia/list/issues"
+  },
+  "main": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "module": "dist/es/index.js",
+  "scripts": {
+    "build": "npm run build-es6; npm run build-cmjs",
+    "build-es6": "tsc -P ./tsconfig-build.json --outDir 'dist/es' --module es2015",
+    "build-cmjs": "tsc -P ./tsconfig-build.json",
+    "postbuild": "babel dist --out-dir dist --no-babelrc --plugins annotate-pure-calls",
+    "test": "nyc mocha --timeout 10000 --recursive test/*.ts",
+    "test-watch": "mocha -R progress --timeout 10000 --watch --require ts-node/register --watch-extensions ts test/*.ts",
+    "test-property": "mocha --timeout 0 --require ts-node/register --recursive test/property/*.ts",
+    "codecov": "codecov -f coverage/coverage-final.json",
+    "format": "prettier --write \"{src,test,scripts}/**/*.{js,ts}\"",
+    "cherry-pick": "cherry-pick --cjs-dir dist --esm-dir dist/es --types-dir dist",
+    "prepublishOnly": "npm run build; npm run cherry-pick",
+    "postpublish": "cherry-pick clean",
+    "release": "np"
+  },
+  "sideEffects": [
+    "**/fantasy-land.js",
+    "**/methods.js"
+  ],
+  "devDependencies": {
+    "@types/chai": "^4.2.3",
+    "@types/mocha": "^5.2.7",
+    "@types/ramda": "^0.26.28",
+    "babel-cli": "^6.26.0",
+    "babel-core": "^6.26.3",
+    "babel-plugin-annotate-pure-calls": "^0.4.0",
+    "chai": "4.2.0",
+    "cherry-pick": "^0.5.0",
+    "codecov": "^3.6.1",
+    "fast-check": "^1.17.0",
+    "mocha": "^6.2.1",
+    "np": "^5.1.0",
+    "nyc": "^14.1.1",
+    "prettier": "1.18.2",
+    "proptest": "0.0.4",
+    "ramda": "0.26.1",
+    "source-map-support": "^0.5.13",
+    "ts-node": "^8.4.1",
+    "tslint": "^5.20.0",
+    "typescript": "^3.6.3"
+  },
+  "files": [
+    "dist",
+    "methods",
+    "curried",
+    "fantasy-land",
+    "ramda"
+  ],
+  "nyc": {
+    "extension": [
+      ".ts"
+    ],
+    "require": [
+      "ts-node/register",
+      "source-map-support/register"
+    ],
+    "include": [
+      "src/**/*.ts"
+    ],
+    "exclude": [
+      "src/methods.ts"
+    ],
+    "reporter": [
+      "json",
+      "html",
+      "text",
+      "lcov"
+    ]
+  },
+  "prettier": {}
+}
diff --git a/node_modules/list/ramda/package.json b/node_modules/list/ramda/package.json
new file mode 100644
index 0000000..a917c54
--- /dev/null
+++ b/node_modules/list/ramda/package.json
@@ -0,0 +1,7 @@
+{
+  "name": "list/ramda",
+  "private": true,
+  "main": "../dist/ramda.js",
+  "module": "../dist/es/ramda.js",
+  "types": "../dist/ramda.d.ts"
+}
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 0000000..2bf9dcc
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,28 @@
+{
+  "name": "ewallet",
+  "version": "1.0.0",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "ewallet",
+      "version": "1.0.0",
+      "license": "ISC",
+      "dependencies": {
+        "list": "^2.0.19"
+      }
+    },
+    "node_modules/list": {
+      "version": "2.0.19",
+      "resolved": "https://registry.npmjs.org/list/-/list-2.0.19.tgz",
+      "integrity": "sha512-nnVaRp4RaMAQkCpypTThsdxKqgPMiSwJq93eAm2/IbpUa8sd04XKBhkKu+bMk63HmdjK8b8Cuh4xARHWX2ye/Q=="
+    }
+  },
+  "dependencies": {
+    "list": {
+      "version": "2.0.19",
+      "resolved": "https://registry.npmjs.org/list/-/list-2.0.19.tgz",
+      "integrity": "sha512-nnVaRp4RaMAQkCpypTThsdxKqgPMiSwJq93eAm2/IbpUa8sd04XKBhkKu+bMk63HmdjK8b8Cuh4xARHWX2ye/Q=="
+    }
+  }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..68f8ba1
--- /dev/null
+++ b/package.json
@@ -0,0 +1,25 @@
+{
+  "name": "ewallet",
+  "version": "1.0.0",
+  "description": "A test app to store income and expenses",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fashuvo/ewallet.git"
+  },
+  "keywords": [
+    "money-management"
+  ],
+  "author": "Foysal Ahmed",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/fashuvo/ewallet/issues"
+  },
+  "homepage": "https://github.com/fashuvo/ewallet#readme",
+  "dependencies": {
+    "list": "^2.0.19"
+  }
+}

From b5ca2bdc54d35c9faf9fe81ad4d6acc1564f6351 Mon Sep 17 00:00:00 2001
From: Foysal Ahmed <fashuvo@MacBook-Pro.local>
Date: Thu, 18 Aug 2022 18:15:05 +0600
Subject: [PATCH 3/3] Update sources section

---
 package.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/package.json b/package.json
index 68f8ba1..39e1492 100644
--- a/package.json
+++ b/package.json
@@ -4,6 +4,7 @@
   "description": "A test app to store income and expenses",
   "main": "index.js",
   "scripts": {
+    "build": "wp-scripts build",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "repository": {