From d1db2e7696e32ac5c7bf9c4d5ed5414f99363172 Mon Sep 17 00:00:00 2001
From: Nathan Faubion <nathan@n-son.com>
Date: Sat, 10 Nov 2018 07:28:21 -0800
Subject: [PATCH 1/2] Frontend updates for 0.12

---
 .gitignore                                   |   1 +
 bower.json                                   | 105 +++++----
 index.html                                   |   2 +
 src/Control/Monad/Eff/JQuery/Extras.purs     |  41 ----
 src/{Control/Monad/Eff => }/JQuery/Extras.js |   0
 src/JQuery/Extras.purs                       |  40 ++++
 src/Main.purs                                | 218 ++++++-------------
 src/Try/API.purs                             |  69 +++---
 src/Try/Gist.purs                            |  51 ++---
 src/Try/QueryString.purs                     |  33 ++-
 src/Try/Session.purs                         |  39 ++--
 11 files changed, 247 insertions(+), 352 deletions(-)
 delete mode 100644 src/Control/Monad/Eff/JQuery/Extras.purs
 rename src/{Control/Monad/Eff => }/JQuery/Extras.js (100%)
 create mode 100644 src/JQuery/Extras.purs

diff --git a/.gitignore b/.gitignore
index 20e090a3..80e9047f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,4 @@
 /.psc*
 /.purs*
 /.psa*
+/.stack*
diff --git a/bower.json b/bower.json
index 185876c7..2ffb3cd6 100644
--- a/bower.json
+++ b/bower.json
@@ -7,68 +7,61 @@
     "output"
   ],
   "dependencies": {
-    "purescript-console": "^3.0.0",
-    "purescript-foreign-generic": "^5.0.0",
-    "purescript-jquery": "^4.2.1",
-    "purescript-js-timers": "^3.0.0",
-    "purescript-parallel": "^3.2.0",
-    "purescript-prelude": "^3.1.0",
-    "purescript-random": "^3.0.0"
+    "purescript-console": "^4.1.0",
+    "purescript-foreign-generic": "^7.0.0",
+    "purescript-jquery": "^5.0.0",
+    "purescript-js-timers": "^4.0.1",
+    "purescript-parallel": "^4.0.0",
+    "purescript-prelude": "^4.1.0",
+    "purescript-random": "^4.0.0",
+    "purescript-web-html": "^1.2.0"
   },
   "devDependencies": {
     "ace": "^1.2.8",
     "jquery": "^3.2.1",
     "underscore": "^1.8.3",
-    "react": "^15.6.1",
+    "react": "^16.1.0",
     "mathbox": "^0.0.5",
-    "purescript-thermite": "^4.1.1",
-    "purescript-behaviors": "^5.2.0",
-    "purescript-slides": "^0.5.0",
-    "purescript-flare": "^3.2.0",
-    "purescript-arrays": "^4.1.2",
-    "purescript-bifunctors": "^3.0.0",
-    "purescript-console": "^3.0.0",
-    "purescript-const": "^3.0.0",
-    "purescript-contravariant": "^3.1.0",
-    "purescript-control": "^3.3.0",
-    "purescript-distributive": "^3.0.0",
-    "purescript-eff": "^3.1.0",
-    "purescript-either": "^3.1.0",
-    "purescript-enums": "^3.2.1",
-    "purescript-exceptions": "^3.1.0",
-    "purescript-exists": "^3.0.0",
-    "purescript-foldable-traversable": "^3.6.0",
-    "purescript-foreign": "^4.0.1",
-    "purescript-free": "^4.1.0",
-    "purescript-functions": "^3.0.0",
-    "purescript-functors": "^2.2.0",
-    "purescript-generics": "^4.0.0",
-    "purescript-generics-rep": "^5.2.0",
-    "purescript-globals": "^3.0.0",
-    "purescript-graphs": "^3.0.0",
-    "purescript-identity": "^3.1.0",
-    "purescript-inject": "^4.0.0",
-    "purescript-integers": "^3.1.0",
-    "purescript-lazy": "^3.0.0",
-    "purescript-maps": "^3.5.2",
+    "purescript-arrays": "^5.1.0",
+    "purescript-bifunctors": "^4.0.0",
+    "purescript-console": "^4.1.0",
+    "purescript-const": "^4.1.0",
+    "purescript-contravariant": "^4.0.0",
+    "purescript-control": "^4.1.0",
+    "purescript-distributive": "^4.0.0",
+    "purescript-effect": "^2.0.0",
+    "purescript-either": "^4.1.0",
+    "purescript-enums": "^4.0.0",
+    "purescript-exceptions": "^4.0.0",
+    "purescript-exists": "^4.0.0",
+    "purescript-foldable-traversable": "^4.1.0",
+    "purescript-foreign": "^5.0.0",
+    "purescript-foreign-object": "^1.0.0",
+    "purescript-free": "^5.1.0",
+    "purescript-functions": "^4.0.0",
+    "purescript-functors": "^3.1.0",
+    "purescript-generics-rep": "^6.1.0",
+    "purescript-globals": "^4.0.0",
+    "purescript-identity": "^4.1.0",
+    "purescript-integers": "^4.0.0",
+    "purescript-lazy": "^4.0.0",
     "purescript-math": "^2.1.0",
-    "purescript-maybe": "^3.0.0",
-    "purescript-monoid": "^3.1.0",
-    "purescript-prelude": "^3.1.0",
-    "purescript-profunctor": "^3.2.0",
-    "purescript-proxy": "^2.1.0",
-    "purescript-quickcheck": "^4.4.0",
-    "purescript-random": "^3.0.0",
-    "purescript-refs": "^3.0.0",
-    "purescript-semirings": "^4.0.0",
-    "purescript-sets": "^3.0.0",
-    "purescript-st": "^3.0.0",
-    "purescript-strings": "^3.3.1",
-    "purescript-tailrec": "^3.3.0",
-    "purescript-transformers": "^3.4.0",
-    "purescript-tuples": "^4.1.0",
-    "purescript-typelevel-prelude": "^2.4.0",
-    "purescript-unfoldable": "^3.0.0",
-    "purescript-validation": "^3.1.0"
+    "purescript-maybe": "^4.0.0",
+    "purescript-ordered-collections": "^1.0.0",
+    "purescript-prelude": "^4.1.0",
+    "purescript-profunctor": "^4.0.0",
+    "purescript-proxy": "^3.0.0",
+    "purescript-quickcheck": "^5.0.0",
+    "purescript-random": "^4.0.0",
+    "purescript-refs": "^4.1.0",
+    "purescript-semirings": "^5.0.0",
+    "purescript-st": "^4.0.0",
+    "purescript-strings": "^4.0.0",
+    "purescript-tailrec": "^4.0.0",
+    "purescript-transformers": "^4.1.0",
+    "purescript-tuples": "^5.1.0",
+    "purescript-typelevel-prelude": "^3.0.0",
+    "purescript-unfoldable": "^4.0.0",
+    "purescript-validation": "^4.0.0"
   }
 }
diff --git a/index.html b/index.html
index 603810bf..8e97044d 100644
--- a/index.html
+++ b/index.html
@@ -54,6 +54,7 @@
               <input type="radio" name="backend_inputs" value="core" id="backend_core" checked="true">
               <label for="backend_core" title="Use the core libraries backend">Core</label>
             </li>
+            <!--
             <li>
               <input type="radio" name="backend_inputs" value="thermite" id="backend_thermite">
               <label for="backend_thermite" title="Use the try-thermite backend">Thermite</label>
@@ -74,6 +75,7 @@
               <input type="radio" name="backend_inputs" value="behaviors" id="backend_behaviors">
               <label for="backend_behaviors" title="Use the try-behaviors backend">Behaviors</label>
             </li>
+            -->
           </ul>
         </li><li class="menu-item view_gist_li mobile-only">
           <a class="view_gist" target="trypurs_gist">
diff --git a/src/Control/Monad/Eff/JQuery/Extras.purs b/src/Control/Monad/Eff/JQuery/Extras.purs
deleted file mode 100644
index 5ba8d381..00000000
--- a/src/Control/Monad/Eff/JQuery/Extras.purs
+++ /dev/null
@@ -1,41 +0,0 @@
-module Control.Monad.Eff.JQuery.Extras
-  ( click
-  , empty
-  , fadeIn
-  , fadeOut
-  , filter
-  , is
-  , getValueMaybe
-  ) where
-
-import Prelude
-
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.JQuery (JQuery, Selector)
-import DOM (DOM)
-import Data.Maybe (Maybe)
-import Data.Nullable (Nullable, toMaybe)
-
--- | Simulate a click event on the specified element.
-foreign import click :: forall eff. JQuery -> Eff (dom :: DOM | eff) Unit
-
--- | Remove all elements from the specified container element.
-foreign import empty :: forall eff. JQuery -> Eff (dom :: DOM | eff) Unit
-
--- | Fade in an element.
-foreign import fadeIn :: forall eff. JQuery -> Eff (dom :: DOM | eff) Unit
-
--- | Fade out an element.
-foreign import fadeOut :: forall eff. JQuery -> Eff (dom :: DOM | eff) Unit
-
--- | Filter elements based on an additional selector.
-foreign import filter :: forall eff. JQuery -> Selector -> Eff (dom :: DOM | eff) JQuery
-
--- | Test whether elements match an additional selector.
-foreign import is :: forall eff. JQuery -> Selector -> Eff (dom :: DOM | eff) Boolean
-
--- | Get the value of the first element, if it exists.
-foreign import getValue :: forall eff. JQuery -> Eff (dom :: DOM | eff) (Nullable String)
-
-getValueMaybe :: forall eff. JQuery -> Eff (dom :: DOM | eff) (Maybe String)
-getValueMaybe = map toMaybe <<< getValue
diff --git a/src/Control/Monad/Eff/JQuery/Extras.js b/src/JQuery/Extras.js
similarity index 100%
rename from src/Control/Monad/Eff/JQuery/Extras.js
rename to src/JQuery/Extras.js
diff --git a/src/JQuery/Extras.purs b/src/JQuery/Extras.purs
new file mode 100644
index 00000000..4602893f
--- /dev/null
+++ b/src/JQuery/Extras.purs
@@ -0,0 +1,40 @@
+module JQuery.Extras
+  ( click
+  , empty
+  , fadeIn
+  , fadeOut
+  , filter
+  , is
+  , getValueMaybe
+  ) where
+
+import Prelude
+
+import Data.Maybe (Maybe)
+import Data.Nullable (Nullable, toMaybe)
+import Effect (Effect)
+import JQuery (JQuery, Selector)
+
+-- | Simulate a click event on the specified element.
+foreign import click :: JQuery -> Effect Unit
+
+-- | Remove all elements from the specified container element.
+foreign import empty :: JQuery -> Effect Unit
+
+-- | Fade in an element.
+foreign import fadeIn :: JQuery -> Effect Unit
+
+-- | Fade out an element.
+foreign import fadeOut :: JQuery -> Effect Unit
+
+-- | Filter elements based on an additional selector.
+foreign import filter :: JQuery -> Selector -> Effect JQuery
+
+-- | Test whether elements match an additional selector.
+foreign import is :: JQuery -> Selector -> Effect Boolean
+
+-- | Get the value of the first element, if it exists.
+foreign import getValue :: JQuery -> Effect (Nullable String)
+
+getValueMaybe :: JQuery -> Effect (Maybe String)
+getValueMaybe = map toMaybe <<< getValue
diff --git a/src/Main.purs b/src/Main.purs
index 10615a9d..6f15ee91 100644
--- a/src/Main.purs
+++ b/src/Main.purs
@@ -3,51 +3,48 @@ module Main where
 import Prelude
 
 import Control.Monad.Cont.Trans (ContT(..), runContT)
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE, error)
-import Control.Monad.Eff.JQuery (JQuery, addClass, append, setText, setAttr, attr, create, hide, on, ready, select, setProp, setValue) as JQuery
-import Control.Monad.Eff.JQuery.Extras (empty, fadeIn, fadeOut, filter, getValueMaybe, is) as JQuery
-import Control.Monad.Eff.Random (RANDOM)
-import Control.Monad.Eff.Timer (TIMER, setTimeout)
-import Control.Monad.Eff.Uncurried (EffFn1, EffFn2, EffFn3, EffFn5, mkEffFn1, runEffFn1, runEffFn2, runEffFn3, runEffFn5)
 import Control.Monad.Except.Trans (runExceptT)
-import DOM (DOM)
-import DOM.HTML (window)
-import DOM.HTML.Location (setHref)
-import DOM.HTML.Types (ALERT, CONFIRM)
-import DOM.HTML.Window (alert, confirm, location)
 import Data.Array (mapMaybe)
 import Data.Array as Array
 import Data.Either (Either(..))
 import Data.Foldable (elem, fold, for_, intercalate, traverse_)
 import Data.FoldableWithIndex (forWithIndex_)
-import Data.Foreign (renderForeignError)
 import Data.Maybe (Maybe(..), fromMaybe)
 import Data.Newtype (unwrap)
-import Data.StrMap as StrMap
 import Data.String (joinWith)
 import Data.String as String
 import Data.String.Regex (replace')
 import Data.String.Regex.Flags (global)
 import Data.String.Regex.Unsafe (unsafeRegex)
+import Effect (Effect)
+import Effect.Console (error)
+import Effect.Timer (setTimeout)
+import Effect.Uncurried (EffectFn1, EffectFn2, EffectFn3, EffectFn5, mkEffectFn1, runEffectFn1, runEffectFn2, runEffectFn3, runEffectFn5)
+import Foreign (renderForeignError)
+import Foreign.Object as Object
+import JQuery as JQuery
+import JQuery.Extras as JQueryExtras
 import Try.API (BackendConfig(..), CompileError(..), CompileResult(..), CompileWarning(..), CompilerError(..), ErrorPosition(..), FailedResult(..), SuccessResult(..), getBackendConfigFromString)
 import Try.API as API
 import Try.Gist (getGistById, tryLoadFileFromGist, uploadGist)
 import Try.QueryString (getQueryStringMaybe, setQueryStrings)
 import Try.Session (createSessionIdIfNecessary, storeSession, tryRetrieveSession)
 import Try.Types (JS(..))
+import Web.HTML (window)
+import Web.HTML.Location (setHref)
+import Web.HTML.Window (alert, confirm, location)
 
-displayLoadingMessage :: forall eff. Eff (dom :: DOM | eff) Unit
-displayLoadingMessage = JQuery.select "#loading" >>= JQuery.fadeIn
+displayLoadingMessage :: Effect Unit
+displayLoadingMessage = JQuery.select "#loading" >>= JQueryExtras.fadeIn
 
-hideLoadingMessage :: forall eff. Eff (dom :: DOM | eff) Unit
-hideLoadingMessage = JQuery.select "#loading" >>= JQuery.fadeOut
+hideLoadingMessage :: Effect Unit
+hideLoadingMessage = JQuery.select "#loading" >>= JQueryExtras.fadeOut
 
 -- | Display a list of errors in the right hand column.
-displayErrors :: forall eff. Array CompilerError -> Eff (dom :: DOM | eff) Unit
+displayErrors :: Array CompilerError -> Effect Unit
 displayErrors errs = do
   column2 <- JQuery.select "#column2"
-  JQuery.empty column2
+  JQueryExtras.empty column2
 
   forWithIndex_ errs \i (CompilerError{ message }) -> do
     h1 <- JQuery.create "<h1>"
@@ -64,52 +61,49 @@ displayErrors errs = do
 
 -- | Display plain text in the right hand column.
 displayPlainText
-  :: forall eff
-   . String
-  -> Eff (dom :: DOM | eff) Unit
+  :: String
+  -> Effect Unit
 displayPlainText s = do
   column2 <- JQuery.select "#column2"
-  JQuery.empty column2
+  JQueryExtras.empty column2
   pre <- JQuery.create "<pre>"
   code_ <- JQuery.create "<code>"
   JQuery.append code_ pre
   JQuery.setText s code_
   JQuery.append pre column2
 
-isShowJsChecked :: forall eff. Eff (dom :: DOM | eff) Boolean
-isShowJsChecked = JQuery.select "#showjs" >>= \jq -> JQuery.is jq ":checked"
+isShowJsChecked :: Effect Boolean
+isShowJsChecked = JQuery.select "#showjs" >>= \jq -> JQueryExtras.is jq ":checked"
 
-isAutoCompileChecked :: forall eff. Eff (dom :: DOM | eff) Boolean
-isAutoCompileChecked = JQuery.select "#auto_compile" >>= \jq -> JQuery.is jq ":checked"
+isAutoCompileChecked :: Effect Boolean
+isAutoCompileChecked = JQuery.select "#auto_compile" >>= \jq -> JQueryExtras.is jq ":checked"
 
 -- | Update the view mode based on the menu selection
-changeViewMode :: forall eff. Maybe String -> Eff (dom :: DOM | eff) Unit
+changeViewMode :: Maybe String -> Effect Unit
 changeViewMode viewMode =
   for_ viewMode \viewMode_ ->
     JQuery.select "#editor_view" >>= JQuery.setAttr "data-view-mode" viewMode_
 
-getTextAreaContent :: forall eff. Eff (dom :: DOM | eff) String
-getTextAreaContent = fold <$> (JQuery.select "#code_textarea" >>= JQuery.getValueMaybe)
+getTextAreaContent :: Effect String
+getTextAreaContent = fold <$> (JQuery.select "#code_textarea" >>= JQueryExtras.getValueMaybe)
 
-setTextAreaContent :: forall eff. String -> Eff (dom :: DOM | eff) Unit
+setTextAreaContent :: String -> Effect Unit
 setTextAreaContent value = JQuery.select "#code_textarea" >>= JQuery.setValue value
 
 -- | Set the editor content to the specified string.
-foreign import setEditorContent :: forall eff. EffFn1 (dom :: DOM | eff) String Unit
+foreign import setEditorContent :: EffectFn1 String Unit
 
 -- | Register a callback for editor change events.
 foreign import onEditorChanged
-  :: forall eff
-   . EffFn2 (dom :: DOM | eff)
-            (EffFn1 (dom :: DOM | eff) String Unit)
-            Int
-            Unit
+  :: EffectFn2 (EffectFn1 String Unit)
+               Int
+               Unit
 
 -- | Clean up any global state associated with any visible error markers.
-foreign import cleanUpMarkers :: forall eff. Eff (dom :: DOM | eff) Unit
+foreign import cleanUpMarkers :: Effect Unit
 
 -- | Add a visible marker at the specified location.
-foreign import addMarker :: forall eff. EffFn5 (dom :: DOM | eff) String Int Int Int Int Unit
+foreign import addMarker :: EffectFn5 String Int Int Int Int Unit
 
 type Annotation =
   { row :: Int
@@ -119,23 +113,21 @@ type Annotation =
   }
 
 -- | Set the gutter annotations
-foreign import setAnnotations :: forall eff. EffFn1 (dom :: DOM | eff) (Array Annotation) Unit
+foreign import setAnnotations :: EffectFn1 (Array Annotation) Unit
 
-clearAnnotations :: forall eff. Eff (dom :: DOM | eff) Unit
-clearAnnotations = runEffFn1 setAnnotations []
+clearAnnotations :: Effect Unit
+clearAnnotations = runEffectFn1 setAnnotations []
 
 -- | Set up a fresh iframe in the specified container, and use it
 -- | to execute the provided JavaScript code.
 foreign import setupIFrame
-  :: forall eff
-   . EffFn3 (dom :: DOM | eff)
-            JQuery.JQuery
-            String
-            String
-            Unit
+  :: EffectFn3 JQuery.JQuery
+               String
+               String
+               Unit
 
 -- | Compile the current code and execute it.
-compile :: forall eff. BackendConfig -> Eff (console :: CONSOLE, dom :: DOM | eff) Unit
+compile :: BackendConfig -> Effect Unit
 compile bc@(BackendConfig backend) = do
   code <- getTextAreaContent
 
@@ -159,15 +151,15 @@ compile bc@(BackendConfig backend) = do
                      case bundleResult of
                        Left err -> error ("Unable to retrieve JS bundle: " <> err)
                        Right bundle -> do
-                         for_ (unwrap warnings) \warnings_ -> do
+                         for_ warnings \warnings_ -> do
                            let toAnnotation (CompileWarning{ errorCode, position, message }) =
-                                 unwrap position <#> \(ErrorPosition pos) ->
+                                 position <#> \(ErrorPosition pos) ->
                                    { row: pos.startLine - 1
                                    , column: pos.startColumn - 1
                                    , type: "warning"
                                    , text: message
                                    }
-                           runEffFn1 setAnnotations (mapMaybe toAnnotation warnings_)
+                           runEffectFn1 setAnnotations (mapMaybe toAnnotation warnings_)
                          execute (JS js) bundle bc
           Right (CompileFailed (FailedResult { error })) -> do
             hideLoadingMessage
@@ -176,17 +168,17 @@ compile bc@(BackendConfig backend) = do
                 displayErrors errs
 
                 let toAnnotation (CompilerError{ position, message }) =
-                      unwrap position <#> \(ErrorPosition pos) ->
+                      position <#> \(ErrorPosition pos) ->
                         { row: pos.startLine - 1
                         , column: pos.startColumn - 1
                         , type: "error"
                         , text: message
                         }
-                runEffFn1 setAnnotations (mapMaybe toAnnotation errs)
+                runEffectFn1 setAnnotations (mapMaybe toAnnotation errs)
 
                 for_ errs \(CompilerError{ position }) ->
-                  for_ (unwrap position) \(ErrorPosition pos) ->
-                    runEffFn5 addMarker
+                  for_ position \(ErrorPosition pos) ->
+                    runEffectFn5 addMarker
                       "error"
                       pos.startLine
                       pos.startColumn
@@ -199,7 +191,7 @@ compile bc@(BackendConfig backend) = do
             traverse_ (error <<< renderForeignError) errs
 
 -- | Execute the compiled code in a new iframe.
-execute :: forall eff. JS -> JS -> BackendConfig -> Eff (dom :: DOM | eff) Unit
+execute :: JS -> JS -> BackendConfig -> Effect Unit
 execute js bundle bc@(BackendConfig backend) = do
   let html = joinWith "\n"
         [ """<!DOCTYPE html>"""
@@ -232,27 +224,18 @@ execute js bundle bc@(BackendConfig backend) = do
       scripts = joinWith "\n" [unwrap bundle, wrapped]
 
   column2 <- JQuery.select "#column2"
-  runEffFn3 setupIFrame column2 html scripts
+  runEffectFn3 setupIFrame column2 html scripts
 
 -- | Setup the editor component and some event handlers.
-setupEditor
-  :: forall eff
-   . { code :: String, backend :: BackendConfig }
-  -> Eff ( alert :: ALERT
-         , console :: CONSOLE
-         , confirm :: CONFIRM
-         , dom :: DOM
-         , timer :: TIMER
-         | eff
-         ) Unit
+setupEditor :: { code :: String, backend :: BackendConfig } -> Effect Unit
 setupEditor { code, backend } = do
   loadOptions backend
   setupBackendMenu backend
 
   setTextAreaContent code
-  runEffFn1 setEditorContent code
+  runEffectFn1 setEditorContent code
 
-  runEffFn2 onEditorChanged (mkEffFn1 \value -> do
+  runEffectFn2 onEditorChanged (mkEffectFn1 \value -> do
     setTextAreaContent value
     cacheCurrentCode backend
     autoCompile <- isAutoCompileChecked
@@ -272,22 +255,10 @@ setupEditor { code, backend } = do
   cacheCurrentCode backend
 
 loadFromGist
-  :: forall eff
-   . String
+  :: String
   -> BackendConfig
-  -> ({ code :: String, backend :: BackendConfig }
-      -> Eff ( alert :: ALERT
-             , console :: CONSOLE
-             , dom :: DOM
-             , timer :: TIMER
-             | eff
-             ) Unit)
-  -> Eff ( alert :: ALERT
-         , console :: CONSOLE
-         , dom :: DOM
-         , timer :: TIMER
-         | eff
-         ) Unit
+  -> ({ code :: String, backend :: BackendConfig } -> Effect Unit)
+  -> Effect Unit
 loadFromGist id_ backend k = do
   runContT (runExceptT (getGistById id_ >>= \gi -> tryLoadFileFromGist gi "Main.purs")) $
     case _ of
@@ -297,23 +268,9 @@ loadFromGist id_ backend k = do
       Right code -> k { code, backend }
 
 withSession
-  :: forall eff
-   . String
-  -> ({ code :: String, backend :: BackendConfig }
-      -> Eff ( alert :: ALERT
-             , confirm :: CONFIRM
-             , console :: CONSOLE
-             , dom :: DOM
-             , timer :: TIMER
-             | eff
-             ) Unit)
-  -> Eff ( alert :: ALERT
-         , confirm :: CONFIRM
-         , console :: CONSOLE
-         , dom :: DOM
-         , timer :: TIMER
-         | eff
-         ) Unit
+  :: String
+  -> ({ code :: String, backend :: BackendConfig } -> Effect Unit)
+  -> Effect Unit
 withSession sessionId k = do
   state <- tryRetrieveSession sessionId
   case state of
@@ -325,10 +282,7 @@ withSession sessionId k = do
       loadFromGist gist bc k
 
 -- | Cache the current code in the session state
-cacheCurrentCode
-  :: forall eff
-   . BackendConfig
-  -> Eff (console :: CONSOLE, dom :: DOM | eff) Unit
+cacheCurrentCode :: BackendConfig -> Effect Unit
 cacheCurrentCode bc@(BackendConfig backend) = do
   sessionId <- getQueryStringMaybe "session"
   case sessionId of
@@ -338,15 +292,7 @@ cacheCurrentCode bc@(BackendConfig backend) = do
     Nothing -> error "No session ID"
 
 -- | Create a new Gist using the current content
-publishNewGist
-  :: forall eff
-   . BackendConfig
-  -> Eff ( alert :: ALERT
-         , confirm :: CONFIRM
-         , console :: CONSOLE
-         , dom :: DOM
-         | eff
-         ) Unit
+publishNewGist :: BackendConfig -> Effect Unit
 publishNewGist bc@(BackendConfig backend) = do
   ok <- window >>= confirm (intercalate "\n"
           [ "Do you really want to publish this code as an anonymous Gist?"
@@ -361,23 +307,15 @@ publishNewGist bc@(BackendConfig backend) = do
           window >>= alert "Failed to create gist"
           error ("Failed to create gist: " <> err)
         Right gistId -> do
-          setQueryStrings (StrMap.singleton "gist" gistId <>
-                           StrMap.singleton "backend" backend.backend)
+          setQueryStrings (Object.singleton "gist" gistId <>
+                           Object.singleton "backend" backend.backend)
 
 -- | Navigate to the specified URL.
-navigateTo :: forall eff. String -> Eff (dom :: DOM | eff) Unit
+navigateTo :: String -> Effect Unit
 navigateTo uri = void (window >>= location >>= setHref uri)
 
 -- | Read query string options and update the state accordingly
-loadOptions
-  :: forall eff
-   . BackendConfig
-  -> Eff ( console :: CONSOLE
-         , confirm :: CONFIRM
-         , dom :: DOM
-         , timer :: TIMER
-         | eff
-         ) Unit
+loadOptions :: BackendConfig -> Effect Unit
 loadOptions bc = do
   viewMode <- getQueryStringMaybe "view"
   case viewMode of
@@ -404,21 +342,11 @@ loadOptions bc = do
     Nothing -> JQuery.select ".view_gist_li" >>= JQuery.hide
 
 -- | Setup event listeners for the backend dropdown menu.
-setupBackendMenu
-  :: forall eff
-   . BackendConfig
-  -> Eff
-       ( dom :: DOM
-       , confirm :: CONFIRM
-       , console :: CONSOLE
-       , timer :: TIMER
-       | eff
-       )
-       Unit
+setupBackendMenu :: BackendConfig -> Effect Unit
 setupBackendMenu bc@(BackendConfig backend) = do
   JQuery.select ("#backend_" <> backend.backend) >>= JQuery.attr { checked: "checked" }
   JQuery.select "input[name=backend_inputs]" >>= JQuery.on "change" \e jq -> do
-    bc_@(BackendConfig newBackend) <- getBackendConfigFromString <<< fromMaybe "core" <$> JQuery.getValueMaybe jq
+    bc_@(BackendConfig newBackend) <- getBackendConfigFromString <<< fromMaybe "core" <$> JQueryExtras.getValueMaybe jq
 
     ok <- window >>= confirm ("Replace your current code with the " <> newBackend.backend <> " backend sample code?")
     if ok
@@ -427,16 +355,10 @@ setupBackendMenu bc@(BackendConfig backend) = do
              compile bc_
              cacheCurrentCode bc_
 
-main :: Eff ( alert :: ALERT
-            , confirm :: CONFIRM
-            , console :: CONSOLE
-            , dom :: DOM
-            , random :: RANDOM
-            , timer :: TIMER
-            ) Unit
+main :: Effect Unit
 main = JQuery.ready do
   JQuery.select "input[name=view_mode]" >>= JQuery.on "change" \_ jq -> do
-    viewMode <- JQuery.filter jq ":checked" >>= JQuery.getValueMaybe
+    viewMode <- JQueryExtras.filter jq ":checked" >>= JQueryExtras.getValueMaybe
     changeViewMode viewMode
 
   runContT (do sessionId <- ContT createSessionIdIfNecessary
diff --git a/src/Try/API.purs b/src/Try/API.purs
index 41539e14..16665187 100644
--- a/src/Try/API.purs
+++ b/src/Try/API.purs
@@ -17,24 +17,23 @@ import Prelude
 
 import Control.Alt ((<|>))
 import Control.Monad.Cont.Trans (ContT(ContT))
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Uncurried (EffFn1, EffFn3, EffFn4, mkEffFn1, runEffFn3, runEffFn4)
 import Control.Monad.Except (runExcept)
 import Control.Monad.Except.Trans (ExceptT(ExceptT))
 import Control.Parallel (parTraverse)
-import DOM (DOM)
 import Data.Array (fold, intercalate)
 import Data.Either (Either(..))
-import Data.Foreign (Foreign, ForeignError)
-import Data.Foreign.Class (class Decode, decode)
-import Data.Foreign.Generic (defaultOptions, genericDecode)
-import Data.Foreign.Generic.Types (Options, SumEncoding(..))
-import Data.Foreign.NullOrUndefined (NullOrUndefined)
 import Data.Generic.Rep (class Generic)
 import Data.List.NonEmpty (NonEmptyList)
+import Data.Maybe (Maybe)
 import Data.String.Regex (replace)
 import Data.String.Regex.Flags (global)
 import Data.String.Regex.Unsafe (unsafeRegex)
+import Effect (Effect)
+import Effect.Uncurried (EffectFn1, EffectFn3, EffectFn4, mkEffectFn1, runEffectFn3, runEffectFn4)
+import Foreign (Foreign, ForeignError)
+import Foreign.Class (class Decode, decode)
+import Foreign.Generic (defaultOptions, genericDecode)
+import Foreign.Generic.Types (Options, SumEncoding(..))
 import Partial.Unsafe (unsafePartial)
 import Try.Types (JS(JS))
 
@@ -56,7 +55,7 @@ instance decodeErrorPosition :: Decode ErrorPosition where
 
 newtype CompilerError = CompilerError
   { message :: String
-  , position :: NullOrUndefined ErrorPosition
+  , position :: Maybe ErrorPosition
   }
 
 derive instance genericCompilerError :: Generic CompilerError _
@@ -78,13 +77,13 @@ instance decodeCompileError :: Decode CompileError where
           TaggedObject
             { tagFieldName: "tag"
             , contentsFieldName: "contents"
-            , constructorTagTransform: id
+            , constructorTagTransform: identity
             }
       })
 
 newtype Suggestion = Suggestion
   { replacement :: String
-  , replaceRange :: NullOrUndefined ErrorPosition
+  , replaceRange :: Maybe ErrorPosition
   }
 
 derive instance genericSuggestion :: Generic Suggestion _
@@ -95,8 +94,8 @@ instance decodeSuggestion :: Decode Suggestion where
 newtype CompileWarning = CompileWarning
   { errorCode :: String
   , message :: String
-  , position :: NullOrUndefined ErrorPosition
-  , suggestion :: NullOrUndefined Suggestion
+  , position :: Maybe ErrorPosition
+  , suggestion :: Maybe Suggestion
   }
 
 derive instance genericCompileWarning :: Generic CompileWarning _
@@ -106,7 +105,7 @@ instance decodeCompileWarning :: Decode CompileWarning where
 
 newtype SuccessResult = SuccessResult
   { js :: String
-  , warnings :: NullOrUndefined (Array CompileWarning)
+  , warnings :: Maybe (Array CompileWarning)
   }
 
 derive instance genericSuccessResult :: Generic SuccessResult _
@@ -134,29 +133,26 @@ instance decodeCompileResult :: Decode CompileResult where
     <|> CompileFailed <$> genericDecode decodingOptions f
 
 foreign import get_
-  :: forall eff
-   . EffFn3 (dom :: DOM | eff)
+  :: EffectFn3
             String
-            (EffFn1 (dom :: DOM | eff) String Unit)
-            (EffFn1 (dom :: DOM | eff) String Unit)
+            (EffectFn1 String Unit)
+            (EffectFn1 String Unit)
             Unit
 
 -- | A wrapper for `get` which uses `ContT`.
-get :: forall eff. String -> ExceptT String (ContT Unit (Eff (dom :: DOM | eff))) String
-get uri = ExceptT (ContT \k -> runEffFn3 get_ uri (mkEffFn1 (k <<< Right)) (mkEffFn1 (k <<< Left)))
+get :: String -> ExceptT String (ContT Unit Effect) String
+get uri = ExceptT (ContT \k -> runEffectFn3 get_ uri (mkEffectFn1 (k <<< Right)) (mkEffectFn1 (k <<< Left)))
 
 -- | Get the default bundle
 getDefaultBundle
-  :: forall eff
-   . String
-  -> ExceptT String (ContT Unit (Eff (dom :: DOM | eff))) JS
+  :: String
+  -> ExceptT String (ContT Unit Effect) JS
 getDefaultBundle endpoint = JS <$> get (endpoint <> "/bundle")
 
 -- | Get the JS bundle for the Thermite backend, which includes additional dependencies
 getThermiteBundle
-  :: forall eff
-   . String
-  -> ExceptT String (ContT Unit (Eff (dom :: DOM | eff))) JS
+  :: String
+  -> ExceptT String (ContT Unit Effect) JS
 getThermiteBundle endpoint =
   let getAll = parTraverse get
         [ "js/console.js"
@@ -179,33 +175,30 @@ getThermiteBundle endpoint =
 -- | POST the specified code to the Try PureScript API, and wait for
 -- | a response.
 foreign import compile_
-  :: forall eff
-   . EffFn4 (dom :: DOM | eff)
+  :: EffectFn4
             String
             String
-            (EffFn1 (dom :: DOM | eff) Foreign Unit)
-            (EffFn1 (dom :: DOM | eff) String Unit)
+            (EffectFn1 Foreign Unit)
+            (EffectFn1 String Unit)
             Unit
 
 -- | A wrapper for `compileApi` which uses `ContT`.
 compile
-  :: forall eff
-   . String
+  :: String
   -> String
-  -> ExceptT String (ContT Unit (Eff (dom :: DOM | eff)))
+  -> ExceptT String (ContT Unit Effect)
        (Either (NonEmptyList ForeignError) CompileResult)
-compile endpoint code = ExceptT (ContT \k -> runEffFn4 compile_ endpoint code (mkEffFn1 (k <<< Right <<< runExcept <<< decode)) (mkEffFn1 (k <<< Left)))
+compile endpoint code = ExceptT (ContT \k -> runEffectFn4 compile_ endpoint code (mkEffectFn1 (k <<< Right <<< runExcept <<< decode)) (mkEffectFn1 (k <<< Left)))
 
 newtype BackendConfig = BackendConfig
   { backend       :: String
   , mainGist      :: String
   , extra_styling :: String
   , extra_body    :: String
-  , compile       :: forall eff
-                   . String
-                  -> ExceptT String (ContT Unit (Eff (dom :: DOM | eff)))
+  , compile       :: String
+                  -> ExceptT String (ContT Unit Effect)
                        (Either (NonEmptyList ForeignError) CompileResult)
-  , getBundle     :: forall eff. ExceptT String (ContT Unit (Eff (dom :: DOM | eff))) JS
+  , getBundle     :: ExceptT String (ContT Unit Effect) JS
   }
 
 data Backend
diff --git a/src/Try/Gist.purs b/src/Try/Gist.purs
index 172b40cb..6057e291 100644
--- a/src/Try/Gist.purs
+++ b/src/Try/Gist.purs
@@ -9,48 +9,41 @@ module Try.Gist
 import Prelude
 
 import Control.Monad.Cont.Trans (ContT(..))
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Uncurried (EffFn1, EffFn3, EffFn4, mkEffFn1, runEffFn3, runEffFn4)
 import Control.Monad.Except.Trans (ExceptT(..))
-import DOM (DOM)
 import Data.Either (Either(..))
+import Effect (Effect)
+import Effect.Uncurried (EffectFn1, EffectFn3, EffectFn4, mkEffectFn1, runEffectFn3, runEffectFn4)
 
 -- | An abstract data type representing the data we get back from the GitHub API.
 data GistInfo
 
 foreign import uploadGist_
-  :: forall eff
-   . EffFn3 (dom :: DOM | eff)
-            String
-            (EffFn1 (dom :: DOM | eff) String Unit)
-            (EffFn1 (dom :: DOM | eff) String Unit)
-            Unit
+  :: EffectFn3 String
+               (EffectFn1 String Unit)
+               (EffectFn1 String Unit)
+               Unit
 
 -- | A wrapper for `uploadGist` which uses `ContT`.
-uploadGist :: forall eff. String -> ExceptT String (ContT Unit (Eff (dom :: DOM | eff))) String
-uploadGist content = ExceptT (ContT \k -> runEffFn3 uploadGist_ content (mkEffFn1 (k <<< Right)) (mkEffFn1 (k <<< Left)))
+uploadGist :: String -> ExceptT String (ContT Unit Effect) String
+uploadGist content = ExceptT (ContT \k -> runEffectFn3 uploadGist_ content (mkEffectFn1 (k <<< Right)) (mkEffectFn1 (k <<< Left)))
 
 -- | Get a gist by its ID
 foreign import getGistById_
-  :: forall eff
-   . EffFn3 (dom :: DOM | eff)
-            String
-            (EffFn1 (dom :: DOM | eff) GistInfo Unit)
-            (EffFn1 (dom :: DOM | eff) String Unit)
-            Unit
+  :: EffectFn3 String
+               (EffectFn1 GistInfo Unit)
+               (EffectFn1 String Unit)
+               Unit
 
 -- | A wrapper for `getGistById` which uses `ContT`.
-getGistById :: forall eff. String -> ExceptT String (ContT Unit (Eff (dom :: DOM | eff))) GistInfo
-getGistById id_ = ExceptT (ContT \k -> runEffFn3 getGistById_ id_ (mkEffFn1 (k <<< Right)) (mkEffFn1 (k <<< Left)))
+getGistById :: String -> ExceptT String (ContT Unit Effect) GistInfo
+getGistById id_ = ExceptT (ContT \k -> runEffectFn3 getGistById_ id_ (mkEffectFn1 (k <<< Right)) (mkEffectFn1 (k <<< Left)))
 
 foreign import tryLoadFileFromGist_
-  :: forall eff
-   . EffFn4 (dom :: DOM | eff)
-            GistInfo
-            String
-            (EffFn1 (dom :: DOM | eff) String Unit)
-            (EffFn1 (dom :: DOM | eff) String Unit)
-            Unit
-
-tryLoadFileFromGist :: forall eff. GistInfo -> String -> ExceptT String (ContT Unit (Eff (dom :: DOM | eff))) String
-tryLoadFileFromGist gi filename = ExceptT (ContT \k -> runEffFn4 tryLoadFileFromGist_ gi filename (mkEffFn1 (k <<< Right)) (mkEffFn1 (k <<< Left)))
+  :: EffectFn4 GistInfo
+               String
+               (EffectFn1 String Unit)
+               (EffectFn1 String Unit)
+               Unit
+
+tryLoadFileFromGist :: GistInfo -> String -> ExceptT String (ContT Unit Effect) String
+tryLoadFileFromGist gi filename = ExceptT (ContT \k -> runEffectFn4 tryLoadFileFromGist_ gi filename (mkEffectFn1 (k <<< Right)) (mkEffectFn1 (k <<< Left)))
diff --git a/src/Try/QueryString.purs b/src/Try/QueryString.purs
index fbb66a4e..8009936a 100644
--- a/src/Try/QueryString.purs
+++ b/src/Try/QueryString.purs
@@ -7,49 +7,48 @@ module Try.QueryString
 
 import Prelude
 
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Uncurried (EffFn1, runEffFn1)
-import DOM (DOM)
 import Data.Array as Array
 import Data.Maybe (Maybe(..))
 import Data.Newtype (wrap)
-import Data.StrMap as StrMap
 import Data.String as String
 import Data.Tuple (Tuple(..))
-import Global (decodeURIComponent)
+import Effect (Effect)
+import Effect.Uncurried (EffectFn1, runEffectFn1)
+import Foreign.Object as Object
+import Global.Unsafe (unsafeDecodeURIComponent)
 
-foreign import getQueryString :: forall eff. Eff (dom :: DOM | eff) String
+foreign import getQueryString :: Effect String
 
 -- | Get all of the URL's query parameters.
-getQueryParams :: forall eff. Eff (dom :: DOM | eff) (StrMap.StrMap String)
+getQueryParams :: Effect (Object.Object String)
 getQueryParams = breakQueryString <$> getQueryString where
-  breakQueryString :: String -> StrMap.StrMap String
+  breakQueryString :: String -> Object.Object String
   breakQueryString =
     String.drop 1
     >>> String.split (wrap "&")
     >>> map (String.split (wrap "=") >>> parseQueryTerm)
     >>> Array.catMaybes
-    >>> StrMap.fromFoldable
+    >>> Object.fromFoldable
 
   parseQueryTerm :: Array String -> Maybe (Tuple String String)
-  parseQueryTerm [k, v] = Just (Tuple k (decodeURIComponent (spaces v)))
+  parseQueryTerm [k, v] = Just (Tuple k (unsafeDecodeURIComponent (spaces v)))
   parseQueryTerm _ = Nothing
 
   spaces :: String -> String
   spaces = String.replaceAll (wrap "+") (wrap " ")
 
 -- | Try to get a key from the URL's query parameters.
-getQueryStringMaybe :: forall eff. String -> Eff (dom :: DOM | eff) (Maybe String)
-getQueryStringMaybe key = StrMap.lookup key <$> getQueryParams
+getQueryStringMaybe :: String -> Effect (Maybe String)
+getQueryStringMaybe key = Object.lookup key <$> getQueryParams
 
 -- | Set the value of a query string parameter
-foreign import setQueryParameters :: forall eff. EffFn1 (dom :: DOM | eff) (StrMap.StrMap String) Unit
+foreign import setQueryParameters :: EffectFn1 (Object.Object String) Unit
 
 -- | Update the specified key in the URL's query parameters.
-setQueryString :: forall eff. String -> String -> Eff (dom :: DOM | eff) Unit
-setQueryString k v = setQueryStrings (StrMap.singleton k v)
+setQueryString :: String -> String -> Effect Unit
+setQueryString k v = setQueryStrings (Object.singleton k v)
 
-setQueryStrings :: forall eff. StrMap.StrMap String -> Eff (dom :: DOM | eff) Unit
+setQueryStrings :: Object.Object String -> Effect Unit
 setQueryStrings ss = do
   params <- getQueryParams
-  runEffFn1 setQueryParameters (StrMap.union ss params)
+  runEffectFn1 setQueryParameters (Object.union ss params)
diff --git a/src/Try/Session.purs b/src/Try/Session.purs
index 0b6d13f1..4eb56823 100644
--- a/src/Try/Session.purs
+++ b/src/Try/Session.purs
@@ -6,19 +6,18 @@ module Try.Session
 
 import Prelude
 
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Random (RANDOM, randomInt)
-import Control.Monad.Eff.Uncurried (EffFn1, EffFn2, runEffFn1, runEffFn2)
-import DOM (DOM)
 import Data.Functor.App (App(..))
 import Data.Int (hexadecimal, toStringAs)
 import Data.Maybe (Maybe(..))
 import Data.Newtype (unwrap)
 import Data.Nullable (Nullable, toMaybe)
 import Data.String as String
+import Effect (Effect)
+import Effect.Random (randomInt)
+import Effect.Uncurried (EffectFn1, EffectFn2, runEffectFn1, runEffectFn2)
 import Try.QueryString (getQueryStringMaybe, setQueryString)
 
-randomGuid :: forall eff. Eff (random :: RANDOM | eff) String
+randomGuid :: Effect String
 randomGuid =
     unwrap (App s4 <> App s4 <> pure "-" <>
             App s4 <> pure "-" <>
@@ -30,35 +29,29 @@ randomGuid =
     padLeft s = String.drop (String.length s - 1) ("000" <> s)
 
 foreign import storeSession_
-  :: forall eff
-   . EffFn2 (dom :: DOM | eff)
-            String
-            { code :: String, backend :: String }
-            Unit
+  :: EffectFn2 String
+               { code :: String, backend :: String }
+               Unit
 
 -- | Store the current session state in local storage
 storeSession
-  :: forall eff
-   . String
+  :: String
   -> { code :: String, backend :: String }
-  -> Eff (dom :: DOM | eff) Unit
-storeSession sessionId values = runEffFn2 storeSession_ sessionId values
+  -> Effect Unit
+storeSession sessionId values = runEffectFn2 storeSession_ sessionId values
 
 foreign import tryRetrieveSession_
-  :: forall eff
-   . EffFn1 (dom :: DOM | eff)
-            String
-            (Nullable { code :: String, backend :: String })
+  :: EffectFn1 String
+               (Nullable { code :: String, backend :: String })
 
 -- | Retrieve the session state from local storage
-tryRetrieveSession :: forall eff. String -> Eff (dom :: DOM | eff) (Maybe { code :: String, backend :: String })
-tryRetrieveSession sessionId = toMaybe <$> runEffFn1 tryRetrieveSession_ sessionId
+tryRetrieveSession :: String -> Effect (Maybe { code :: String, backend :: String })
+tryRetrieveSession sessionId = toMaybe <$> runEffectFn1 tryRetrieveSession_ sessionId
 
 -- | Look up the session by ID, or create a new session ID.
 createSessionIdIfNecessary
-  :: forall eff
-   . (String -> Eff (dom :: DOM, random :: RANDOM | eff) Unit)
-  -> Eff (dom :: DOM, random :: RANDOM | eff) Unit
+  :: (String -> Effect Unit)
+  -> Effect Unit
 createSessionIdIfNecessary k = do
   sessionId <- getQueryStringMaybe "session"
   case sessionId of

From e92b49d3b26f0e526f465c9803ed5b7183da57d4 Mon Sep 17 00:00:00 2001
From: Nathan Faubion <nathan@n-son.com>
Date: Sat, 10 Nov 2018 09:52:53 -0800
Subject: [PATCH 2/2] Fix require, bundle

---
 js/index.js   | 6944 +++++++++++++++++++++++++++----------------------
 src/Main.purs |    2 +-
 2 files changed, 3831 insertions(+), 3115 deletions(-)

diff --git a/js/index.js b/js/index.js
index 1db1a64d..94258e73 100644
--- a/js/index.js
+++ b/js/index.js
@@ -1,4 +1,4 @@
-// Generated by purs bundle 0.11.6
+// Generated by purs bundle 0.12.0
 var PS = {};
 (function(exports) {
     "use strict";
@@ -15,7 +15,7 @@ var PS = {};
   };
 })(PS["Data.Functor"] = PS["Data.Functor"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var Semigroupoid = function (compose) {
       this.compose = compose;
@@ -30,20 +30,28 @@ var PS = {};
   var compose = function (dict) {
       return dict.compose;
   };
+  var composeFlipped = function (dictSemigroupoid) {
+      return function (f) {
+          return function (g) {
+              return compose(dictSemigroupoid)(g)(f);
+          };
+      };
+  };
   exports["compose"] = compose;
   exports["Semigroupoid"] = Semigroupoid;
+  exports["composeFlipped"] = composeFlipped;
   exports["semigroupoidFn"] = semigroupoidFn;
 })(PS["Control.Semigroupoid"] = PS["Control.Semigroupoid"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];        
-  var Category = function (Semigroupoid0, id) {
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];                 
+  var Category = function (Semigroupoid0, identity) {
       this.Semigroupoid0 = Semigroupoid0;
-      this.id = id;
+      this.identity = identity;
   };
-  var id = function (dict) {
-      return dict.id;
+  var identity = function (dict) {
+      return dict.identity;
   };
   var categoryFn = new Category(function () {
       return Control_Semigroupoid.semigroupoidFn;
@@ -51,28 +59,64 @@ var PS = {};
       return x;
   });
   exports["Category"] = Category;
-  exports["id"] = id;
+  exports["identity"] = identity;
   exports["categoryFn"] = categoryFn;
 })(PS["Control.Category"] = PS["Control.Category"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Category = PS["Control.Category"];
-  var flip = function (f) {
-      return function (b) {
-          return function (a) {
-              return f(a)(b);
-          };
-      };
+  var otherwise = true;
+  exports["otherwise"] = otherwise;
+})(PS["Data.Boolean"] = PS["Data.Boolean"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.refEq = function (r1) {
+    return function (r2) {
+      return r1 === r2;
+    };
   };
-  var $$const = function (a) {
-      return function (v) {
-          return a;
+})(PS["Data.Eq"] = PS["Data.Eq"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.boolConj = function (b1) {
+    return function (b2) {
+      return b1 && b2;
+    };
+  };
+
+  exports.boolDisj = function (b1) {
+    return function (b2) {
+      return b1 || b2;
+    };
+  };
+
+  exports.boolNot = function (b) {
+    return !b;
+  };
+})(PS["Data.HeytingAlgebra"] = PS["Data.HeytingAlgebra"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Symbol"];      
+  var SProxy = (function () {
+      function SProxy() {
+
       };
+      SProxy.value = new SProxy();
+      return SProxy;
+  })();
+  var IsSymbol = function (reflectSymbol) {
+      this.reflectSymbol = reflectSymbol;
   };
-  exports["flip"] = flip;
-  exports["const"] = $$const;
-})(PS["Data.Function"] = PS["Data.Function"] || {});
+  var reflectSymbol = function (dict) {
+      return dict.reflectSymbol;
+  };
+  exports["IsSymbol"] = IsSymbol;
+  exports["reflectSymbol"] = reflectSymbol;
+  exports["SProxy"] = SProxy;
+})(PS["Data.Symbol"] = PS["Data.Symbol"] || {});
 (function(exports) {
     "use strict";
 
@@ -110,9 +154,24 @@ var PS = {};
   };
 })(PS["Data.Show"] = PS["Data.Show"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
+  "use strict";
+  var RLProxy = (function () {
+      function RLProxy() {
+
+      };
+      RLProxy.value = new RLProxy();
+      return RLProxy;
+  })();
+  exports["RLProxy"] = RLProxy;
+})(PS["Type.Data.RowList"] = PS["Type.Data.RowList"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.Show"];     
+  var $foreign = PS["Data.Show"];
+  var Data_Symbol = PS["Data.Symbol"];
+  var Record_Unsafe = PS["Record.Unsafe"];
+  var Type_Data_RowList = PS["Type.Data.RowList"];                 
   var Show = function (show) {
       this.show = show;
   };
@@ -127,44 +186,101 @@ var PS = {};
   exports["showString"] = showString;
 })(PS["Data.Show"] = PS["Data.Show"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Data.Unit"];
   var Data_Show = PS["Data.Show"];
   exports["unit"] = $foreign.unit;
 })(PS["Data.Unit"] = PS["Data.Unit"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.Functor"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Unit = PS["Data.Unit"];        
-  var Functor = function (map) {
-      this.map = map;
+  var $foreign = PS["Data.HeytingAlgebra"];
+  var Data_Symbol = PS["Data.Symbol"];
+  var Data_Unit = PS["Data.Unit"];
+  var Record_Unsafe = PS["Record.Unsafe"];
+  var Type_Data_Row = PS["Type.Data.Row"];
+  var Type_Data_RowList = PS["Type.Data.RowList"];                 
+  var HeytingAlgebra = function (conj, disj, ff, implies, not, tt) {
+      this.conj = conj;
+      this.disj = disj;
+      this.ff = ff;
+      this.implies = implies;
+      this.not = not;
+      this.tt = tt;
   };
-  var map = function (dict) {
-      return dict.map;
+  var tt = function (dict) {
+      return dict.tt;
   };
-  var mapFlipped = function (dictFunctor) {
-      return function (fa) {
-          return function (f) {
-              return map(dictFunctor)(f)(fa);
-          };
+  var not = function (dict) {
+      return dict.not;
+  };
+  var implies = function (dict) {
+      return dict.implies;
+  };
+  var ff = function (dict) {
+      return dict.ff;
+  };
+  var disj = function (dict) {
+      return dict.disj;
+  };
+  var heytingAlgebraBoolean = new HeytingAlgebra($foreign.boolConj, $foreign.boolDisj, false, function (a) {
+      return function (b) {
+          return disj(heytingAlgebraBoolean)(not(heytingAlgebraBoolean)(a))(b);
       };
+  }, $foreign.boolNot, true);
+  var conj = function (dict) {
+      return dict.conj;
   };
-  var $$void = function (dictFunctor) {
-      return map(dictFunctor)(Data_Function["const"](Data_Unit.unit));
+  exports["HeytingAlgebra"] = HeytingAlgebra;
+  exports["tt"] = tt;
+  exports["ff"] = ff;
+  exports["implies"] = implies;
+  exports["conj"] = conj;
+  exports["disj"] = disj;
+  exports["not"] = not;
+  exports["heytingAlgebraBoolean"] = heytingAlgebraBoolean;
+})(PS["Data.HeytingAlgebra"] = PS["Data.HeytingAlgebra"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Eq"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Symbol = PS["Data.Symbol"];
+  var Data_Unit = PS["Data.Unit"];
+  var Data_Void = PS["Data.Void"];
+  var Record_Unsafe = PS["Record.Unsafe"];
+  var Type_Data_RowList = PS["Type.Data.RowList"];                 
+  var Eq = function (eq) {
+      this.eq = eq;
+  }; 
+  var eqString = new Eq($foreign.refEq);
+  var eqInt = new Eq($foreign.refEq);
+  var eqChar = new Eq($foreign.refEq);
+  var eq = function (dict) {
+      return dict.eq;
   };
-  var functorFn = new Functor(Control_Semigroupoid.compose(Control_Semigroupoid.semigroupoidFn));
-  var functorArray = new Functor($foreign.arrayMap);
-  exports["Functor"] = Functor;
-  exports["map"] = map;
-  exports["mapFlipped"] = mapFlipped;
-  exports["void"] = $$void;
-  exports["functorFn"] = functorFn;
-  exports["functorArray"] = functorArray;
-})(PS["Data.Functor"] = PS["Data.Functor"] || {});
+  exports["Eq"] = Eq;
+  exports["eq"] = eq;
+  exports["eqInt"] = eqInt;
+  exports["eqChar"] = eqChar;
+  exports["eqString"] = eqString;
+})(PS["Data.Eq"] = PS["Data.Eq"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.unsafeCompareImpl = function (lt) {
+    return function (eq) {
+      return function (gt) {
+        return function (x) {
+          return function (y) {
+            return x < y ? lt : x === y ? eq : gt;
+          };
+        };
+      };
+    };
+  };
+})(PS["Data.Ord.Unsafe"] = PS["Data.Ord.Unsafe"] || {});
 (function(exports) {
     "use strict";
 
@@ -175,11 +291,14 @@ var PS = {};
   };
 })(PS["Data.Semigroup"] = PS["Data.Semigroup"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Data.Semigroup"];
+  var Data_Symbol = PS["Data.Symbol"];
   var Data_Unit = PS["Data.Unit"];
-  var Data_Void = PS["Data.Void"];        
+  var Data_Void = PS["Data.Void"];
+  var Record_Unsafe = PS["Record.Unsafe"];
+  var Type_Data_RowList = PS["Type.Data.RowList"];                 
   var Semigroup = function (append) {
       this.append = append;
   }; 
@@ -192,81 +311,294 @@ var PS = {};
   exports["semigroupString"] = semigroupString;
 })(PS["Data.Semigroup"] = PS["Data.Semigroup"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Semigroup = PS["Data.Semigroup"];        
-  var Alt = function (Functor0, alt) {
-      this.Functor0 = Functor0;
-      this.alt = alt;
-  };                                                       
-  var alt = function (dict) {
-      return dict.alt;
-  };
-  exports["Alt"] = Alt;
-  exports["alt"] = alt;
-})(PS["Control.Alt"] = PS["Control.Alt"] || {});
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Show = PS["Data.Show"];                 
+  var LT = (function () {
+      function LT() {
+
+      };
+      LT.value = new LT();
+      return LT;
+  })();
+  var GT = (function () {
+      function GT() {
+
+      };
+      GT.value = new GT();
+      return GT;
+  })();
+  var EQ = (function () {
+      function EQ() {
+
+      };
+      EQ.value = new EQ();
+      return EQ;
+  })();
+  exports["LT"] = LT;
+  exports["GT"] = GT;
+  exports["EQ"] = EQ;
+})(PS["Data.Ordering"] = PS["Data.Ordering"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Ord.Unsafe"];
+  var Data_Ordering = PS["Data.Ordering"];                 
+  var unsafeCompare = $foreign.unsafeCompareImpl(Data_Ordering.LT.value)(Data_Ordering.EQ.value)(Data_Ordering.GT.value);
+  exports["unsafeCompare"] = unsafeCompare;
+})(PS["Data.Ord.Unsafe"] = PS["Data.Ord.Unsafe"] || {});
 (function(exports) {
     "use strict";
 
-  exports.arrayApply = function (fs) {
-    return function (xs) {
-      var result = [];
-      var n = 0;
-      for (var i = 0, l = fs.length; i < l; i++) {
-        for (var j = 0, k = xs.length; j < k; j++) {
-          result[n++] = fs[i](xs[j]);
-        }
-      }
-      return result;
+  exports.intSub = function (x) {
+    return function (y) {
+      /* jshint bitwise: false */
+      return x - y | 0;
     };
   };
-})(PS["Control.Apply"] = PS["Control.Apply"] || {});
+})(PS["Data.Ring"] = PS["Data.Ring"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Control.Apply"];
-  var Control_Category = PS["Control.Category"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Functor = PS["Data.Functor"];        
-  var Apply = function (Functor0, apply) {
-      this.Functor0 = Functor0;
-      this.apply = apply;
-  }; 
-  var applyArray = new Apply(function () {
-      return Data_Functor.functorArray;
-  }, $foreign.arrayApply);
-  var apply = function (dict) {
-      return dict.apply;
-  };
-  var applySecond = function (dictApply) {
-      return function (a) {
-          return function (b) {
-              return apply(dictApply)(Data_Functor.map(dictApply.Functor0())(Data_Function["const"](Control_Category.id(Control_Category.categoryFn)))(a))(b);
-          };
-      };
+    "use strict";
+
+  exports.intAdd = function (x) {
+    return function (y) {
+      /* jshint bitwise: false */
+      return x + y | 0;
+    };
   };
-  var lift2 = function (dictApply) {
-      return function (f) {
-          return function (a) {
-              return function (b) {
-                  return apply(dictApply)(Data_Functor.map(dictApply.Functor0())(f)(a))(b);
-              };
-          };
-      };
+
+  exports.intMul = function (x) {
+    return function (y) {
+      /* jshint bitwise: false */
+      return x * y | 0;
+    };
   };
-  exports["Apply"] = Apply;
-  exports["apply"] = apply;
-  exports["applySecond"] = applySecond;
-  exports["lift2"] = lift2;
-  exports["applyArray"] = applyArray;
+})(PS["Data.Semiring"] = PS["Data.Semiring"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Semiring"];
+  var Data_Symbol = PS["Data.Symbol"];
+  var Data_Unit = PS["Data.Unit"];
+  var Record_Unsafe = PS["Record.Unsafe"];
+  var Type_Data_Row = PS["Type.Data.Row"];
+  var Type_Data_RowList = PS["Type.Data.RowList"];                 
+  var Semiring = function (add, mul, one, zero) {
+      this.add = add;
+      this.mul = mul;
+      this.one = one;
+      this.zero = zero;
+  };
+  var zero = function (dict) {
+      return dict.zero;
+  };                                                                            
+  var semiringInt = new Semiring($foreign.intAdd, $foreign.intMul, 1, 0);
+  var one = function (dict) {
+      return dict.one;
+  };
+  var mul = function (dict) {
+      return dict.mul;
+  };
+  var add = function (dict) {
+      return dict.add;
+  };
+  exports["Semiring"] = Semiring;
+  exports["add"] = add;
+  exports["zero"] = zero;
+  exports["mul"] = mul;
+  exports["one"] = one;
+  exports["semiringInt"] = semiringInt;
+})(PS["Data.Semiring"] = PS["Data.Semiring"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Ring"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Symbol = PS["Data.Symbol"];
+  var Data_Unit = PS["Data.Unit"];
+  var Record_Unsafe = PS["Record.Unsafe"];
+  var Type_Data_RowList = PS["Type.Data.RowList"];                 
+  var Ring = function (Semiring0, sub) {
+      this.Semiring0 = Semiring0;
+      this.sub = sub;
+  };
+  var sub = function (dict) {
+      return dict.sub;
+  };                  
+  var ringInt = new Ring(function () {
+      return Data_Semiring.semiringInt;
+  }, $foreign.intSub);
+  exports["Ring"] = Ring;
+  exports["sub"] = sub;
+  exports["ringInt"] = ringInt;
+})(PS["Data.Ring"] = PS["Data.Ring"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Ord"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Ord_Unsafe = PS["Data.Ord.Unsafe"];
+  var Data_Ordering = PS["Data.Ordering"];
+  var Data_Ring = PS["Data.Ring"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Symbol = PS["Data.Symbol"];
+  var Data_Unit = PS["Data.Unit"];
+  var Data_Void = PS["Data.Void"];
+  var Record_Unsafe = PS["Record.Unsafe"];
+  var Type_Data_RowList = PS["Type.Data.RowList"];                 
+  var Ord = function (Eq0, compare) {
+      this.Eq0 = Eq0;
+      this.compare = compare;
+  };                                
+  var ordInt = new Ord(function () {
+      return Data_Eq.eqInt;
+  }, Data_Ord_Unsafe.unsafeCompare);
+  var ordChar = new Ord(function () {
+      return Data_Eq.eqChar;
+  }, Data_Ord_Unsafe.unsafeCompare);
+  var compare = function (dict) {
+      return dict.compare;
+  };
+  exports["Ord"] = Ord;
+  exports["compare"] = compare;
+  exports["ordInt"] = ordInt;
+  exports["ordChar"] = ordChar;
+})(PS["Data.Ord"] = PS["Data.Ord"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Category = PS["Control.Category"];
+  var Data_Boolean = PS["Data.Boolean"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ring = PS["Data.Ring"];
+  var flip = function (f) {
+      return function (b) {
+          return function (a) {
+              return f(a)(b);
+          };
+      };
+  };
+  var $$const = function (a) {
+      return function (v) {
+          return a;
+      };
+  };
+  exports["flip"] = flip;
+  exports["const"] = $$const;
+})(PS["Data.Function"] = PS["Data.Function"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Functor"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Unit = PS["Data.Unit"];                 
+  var Functor = function (map) {
+      this.map = map;
+  };
+  var map = function (dict) {
+      return dict.map;
+  };
+  var mapFlipped = function (dictFunctor) {
+      return function (fa) {
+          return function (f) {
+              return map(dictFunctor)(f)(fa);
+          };
+      };
+  };
+  var $$void = function (dictFunctor) {
+      return map(dictFunctor)(Data_Function["const"](Data_Unit.unit));
+  };
+  var functorFn = new Functor(Control_Semigroupoid.compose(Control_Semigroupoid.semigroupoidFn));
+  var functorArray = new Functor($foreign.arrayMap);
+  exports["Functor"] = Functor;
+  exports["map"] = map;
+  exports["mapFlipped"] = mapFlipped;
+  exports["void"] = $$void;
+  exports["functorFn"] = functorFn;
+  exports["functorArray"] = functorArray;
+})(PS["Data.Functor"] = PS["Data.Functor"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Semigroup = PS["Data.Semigroup"];                 
+  var Alt = function (Functor0, alt) {
+      this.Functor0 = Functor0;
+      this.alt = alt;
+  };                                                       
+  var alt = function (dict) {
+      return dict.alt;
+  };
+  exports["Alt"] = Alt;
+  exports["alt"] = alt;
+})(PS["Control.Alt"] = PS["Control.Alt"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.arrayApply = function (fs) {
+    return function (xs) {
+      var l = fs.length;
+      var k = xs.length;
+      var result = new Array(l*k);
+      var n = 0;
+      for (var i = 0; i < l; i++) {
+        var f = fs[i];
+        for (var j = 0; j < k; j++) {
+          result[n++] = f(xs[j]);
+        }
+      }
+      return result;
+    };
+  };
+})(PS["Control.Apply"] = PS["Control.Apply"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Control.Apply"];
+  var Control_Category = PS["Control.Category"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];                 
+  var Apply = function (Functor0, apply) {
+      this.Functor0 = Functor0;
+      this.apply = apply;
+  }; 
+  var applyArray = new Apply(function () {
+      return Data_Functor.functorArray;
+  }, $foreign.arrayApply);
+  var apply = function (dict) {
+      return dict.apply;
+  };
+  var applySecond = function (dictApply) {
+      return function (a) {
+          return function (b) {
+              return apply(dictApply)(Data_Functor.map(dictApply.Functor0())(Data_Function["const"](Control_Category.identity(Control_Category.categoryFn)))(a))(b);
+          };
+      };
+  };
+  var lift2 = function (dictApply) {
+      return function (f) {
+          return function (a) {
+              return function (b) {
+                  return apply(dictApply)(Data_Functor.map(dictApply.Functor0())(f)(a))(b);
+              };
+          };
+      };
+  };
+  exports["Apply"] = Apply;
+  exports["apply"] = apply;
+  exports["applySecond"] = applySecond;
+  exports["lift2"] = lift2;
+  exports["applyArray"] = applyArray;
 })(PS["Control.Apply"] = PS["Control.Apply"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Apply = PS["Control.Apply"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_Unit = PS["Data.Unit"];        
+  var Data_Unit = PS["Data.Unit"];                 
   var Applicative = function (Apply0, pure) {
       this.Apply0 = Apply0;
       this.pure = pure;
@@ -327,7 +659,7 @@ var PS = {};
   };
 })(PS["Control.Bind"] = PS["Control.Bind"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Control.Bind"];
   var Control_Applicative = PS["Control.Applicative"];
@@ -335,7 +667,7 @@ var PS = {};
   var Control_Category = PS["Control.Category"];
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_Unit = PS["Data.Unit"];        
+  var Data_Unit = PS["Data.Unit"];                 
   var Bind = function (Apply0, bind) {
       this.Apply0 = Apply0;
       this.bind = bind;
@@ -352,6 +684,9 @@ var PS = {};
   var bind = function (dict) {
       return dict.bind;
   };
+  var bindFlipped = function (dictBind) {
+      return Data_Function.flip(bind(dictBind));
+  };
   var composeKleisli = function (dictBind) {
       return function (f) {
           return function (g) {
@@ -366,6 +701,7 @@ var PS = {};
   });
   exports["Bind"] = Bind;
   exports["bind"] = bind;
+  exports["bindFlipped"] = bindFlipped;
   exports["Discard"] = Discard;
   exports["discard"] = discard;
   exports["composeKleisli"] = composeKleisli;
@@ -373,13 +709,13 @@ var PS = {};
   exports["discardUnit"] = discardUnit;
 })(PS["Control.Bind"] = PS["Control.Bind"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_Unit = PS["Data.Unit"];        
+  var Data_Unit = PS["Data.Unit"];                 
   var Monad = function (Applicative0, Bind1) {
       this.Applicative0 = Applicative0;
       this.Bind1 = Bind1;
@@ -401,112 +737,215 @@ var PS = {};
 (function(exports) {
     "use strict";
 
-  exports.pureE = function (a) {
-    return function () {
-      return a;
-    };
+  exports.topInt = 2147483647;
+  exports.bottomInt = -2147483648;
+
+  exports.topChar = String.fromCharCode(65535);
+  exports.bottomChar = String.fromCharCode(0);
+})(PS["Data.Bounded"] = PS["Data.Bounded"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Bounded"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ordering = PS["Data.Ordering"];
+  var Data_Unit = PS["Data.Unit"];                 
+  var Bounded = function (Ord0, bottom, top) {
+      this.Ord0 = Ord0;
+      this.bottom = bottom;
+      this.top = top;
+  };
+  var top = function (dict) {
+      return dict.top;
+  };                                            
+  var boundedInt = new Bounded(function () {
+      return Data_Ord.ordInt;
+  }, $foreign.bottomInt, $foreign.topInt);
+  var boundedChar = new Bounded(function () {
+      return Data_Ord.ordChar;
+  }, $foreign.bottomChar, $foreign.topChar);
+  var bottom = function (dict) {
+      return dict.bottom;
   };
+  exports["Bounded"] = Bounded;
+  exports["bottom"] = bottom;
+  exports["top"] = top;
+  exports["boundedInt"] = boundedInt;
+  exports["boundedChar"] = boundedChar;
+})(PS["Data.Bounded"] = PS["Data.Bounded"] || {});
+(function(exports) {
+    "use strict";
 
-  exports.bindE = function (a) {
-    return function (f) {
-      return function () {
-        return f(a())();
-      };
-    };
+  exports.intDegree = function (x) {
+    return Math.min(Math.abs(x), 2147483647);
   };
 
-  exports.runPure = function (f) {
-    return f();
+  // See the Euclidean definition in
+  // https://en.m.wikipedia.org/wiki/Modulo_operation.
+  exports.intDiv = function (x) {
+    return function (y) {
+      if (y === 0) return 0;
+      return y > 0 ? Math.floor(x / y) : -Math.floor(x / -y);
+    };
   };
 
-  exports.foreachE = function (as) {
-    return function (f) {
-      return function () {
-        for (var i = 0, l = as.length; i < l; i++) {
-          f(as[i])();
-        }
-      };
+  exports.intMod = function (x) {
+    return function (y) {
+      if (y === 0) return 0;
+      var yy = Math.abs(y);
+      return ((x % yy) + yy) % yy;
     };
   };
-})(PS["Control.Monad.Eff"] = PS["Control.Monad.Eff"] || {});
+})(PS["Data.EuclideanRing"] = PS["Data.EuclideanRing"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Control.Monad.Eff"];
-  var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
-  var Control_Bind = PS["Control.Bind"];
-  var Control_Monad = PS["Control.Monad"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Unit = PS["Data.Unit"];        
-  var monadEff = new Control_Monad.Monad(function () {
-      return applicativeEff;
-  }, function () {
-      return bindEff;
+  var Data_Ring = PS["Data.Ring"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Symbol = PS["Data.Symbol"];
+  var Data_Unit = PS["Data.Unit"];                 
+  var CommutativeRing = function (Ring0) {
+      this.Ring0 = Ring0;
+  }; 
+  var commutativeRingInt = new CommutativeRing(function () {
+      return Data_Ring.ringInt;
   });
-  var bindEff = new Control_Bind.Bind(function () {
-      return applyEff;
-  }, $foreign.bindE);
-  var applyEff = new Control_Apply.Apply(function () {
-      return functorEff;
-  }, Control_Monad.ap(monadEff));
-  var applicativeEff = new Control_Applicative.Applicative(function () {
-      return applyEff;
-  }, $foreign.pureE);
-  var functorEff = new Data_Functor.Functor(Control_Applicative.liftA1(applicativeEff));
-  exports["functorEff"] = functorEff;
-  exports["applyEff"] = applyEff;
-  exports["applicativeEff"] = applicativeEff;
-  exports["bindEff"] = bindEff;
-  exports["monadEff"] = monadEff;
-  exports["runPure"] = $foreign.runPure;
-  exports["foreachE"] = $foreign.foreachE;
-})(PS["Control.Monad.Eff"] = PS["Control.Monad.Eff"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
+  exports["CommutativeRing"] = CommutativeRing;
+  exports["commutativeRingInt"] = commutativeRingInt;
+})(PS["Data.CommutativeRing"] = PS["Data.CommutativeRing"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Category = PS["Control.Category"];
-  var Control_Monad = PS["Control.Monad"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];        
-  var MonadEff = function (Monad0, liftEff) {
-      this.Monad0 = Monad0;
-      this.liftEff = liftEff;
-  };
-  var monadEffEff = new MonadEff(function () {
-      return Control_Monad_Eff.monadEff;
-  }, Control_Category.id(Control_Category.categoryFn));
-  var liftEff = function (dict) {
-      return dict.liftEff;
+  var $foreign = PS["Data.EuclideanRing"];
+  var Data_BooleanAlgebra = PS["Data.BooleanAlgebra"];
+  var Data_CommutativeRing = PS["Data.CommutativeRing"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Ring = PS["Data.Ring"];
+  var Data_Semiring = PS["Data.Semiring"];                 
+  var EuclideanRing = function (CommutativeRing0, degree, div, mod) {
+      this.CommutativeRing0 = CommutativeRing0;
+      this.degree = degree;
+      this.div = div;
+      this.mod = mod;
+  };
+  var mod = function (dict) {
+      return dict.mod;
+  }; 
+  var euclideanRingInt = new EuclideanRing(function () {
+      return Data_CommutativeRing.commutativeRingInt;
+  }, $foreign.intDegree, $foreign.intDiv, $foreign.intMod);
+  var div = function (dict) {
+      return dict.div;
+  };
+  var degree = function (dict) {
+      return dict.degree;
+  };
+  exports["EuclideanRing"] = EuclideanRing;
+  exports["degree"] = degree;
+  exports["div"] = div;
+  exports["mod"] = mod;
+  exports["euclideanRingInt"] = euclideanRingInt;
+})(PS["Data.EuclideanRing"] = PS["Data.EuclideanRing"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Data_Boolean = PS["Data.Boolean"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_EuclideanRing = PS["Data.EuclideanRing"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ordering = PS["Data.Ordering"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Symbol = PS["Data.Symbol"];
+  var Data_Unit = PS["Data.Unit"];
+  var Record_Unsafe = PS["Record.Unsafe"];
+  var Type_Data_RowList = PS["Type.Data.RowList"];                 
+  var Monoid = function (Semigroup0, mempty) {
+      this.Semigroup0 = Semigroup0;
+      this.mempty = mempty;
+  };                 
+  var monoidString = new Monoid(function () {
+      return Data_Semigroup.semigroupString;
+  }, "");
+  var mempty = function (dict) {
+      return dict.mempty;
   };
-  exports["liftEff"] = liftEff;
-  exports["MonadEff"] = MonadEff;
-  exports["monadEffEff"] = monadEffEff;
-})(PS["Control.Monad.Eff.Class"] = PS["Control.Monad.Eff.Class"] || {});
+  exports["Monoid"] = Monoid;
+  exports["mempty"] = mempty;
+  exports["monoidString"] = monoidString;
+})(PS["Data.Monoid"] = PS["Data.Monoid"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Function = PS["Data.Function"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Monad = PS["Control.Monad"];
+  var Data_Bounded = PS["Data.Bounded"];
+  var Data_Eq = PS["Data.Eq"];
   var Data_Functor = PS["Data.Functor"];
-  var Prelude = PS["Prelude"];        
-  var Newtype = function (unwrap, wrap) {
-      this.unwrap = unwrap;
-      this.wrap = wrap;
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Show = PS["Data.Show"];
+  var Prelude = PS["Prelude"];                 
+  var Disj = function (x) {
+      return x;
+  };
+  var semigroupDisj = function (dictHeytingAlgebra) {
+      return new Data_Semigroup.Semigroup(function (v) {
+          return function (v1) {
+              return Data_HeytingAlgebra.disj(dictHeytingAlgebra)(v)(v1);
+          };
+      });
+  };
+  var monoidDisj = function (dictHeytingAlgebra) {
+      return new Data_Monoid.Monoid(function () {
+          return semigroupDisj(dictHeytingAlgebra);
+      }, Data_HeytingAlgebra.ff(dictHeytingAlgebra));
+  };
+  exports["Disj"] = Disj;
+  exports["semigroupDisj"] = semigroupDisj;
+  exports["monoidDisj"] = monoidDisj;
+})(PS["Data.Monoid.Disj"] = PS["Data.Monoid.Disj"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
+  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
+  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
+  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
+  var Data_Monoid_Endo = PS["Data.Monoid.Endo"];
+  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
+  var Data_Semigroup_First = PS["Data.Semigroup.First"];
+  var Data_Semigroup_Last = PS["Data.Semigroup.Last"];
+  var Prelude = PS["Prelude"];                 
+  var Newtype = function (unwrap, wrap) {
+      this.unwrap = unwrap;
+      this.wrap = wrap;
   };
   var wrap = function (dict) {
       return dict.wrap;
   };
   var unwrap = function (dict) {
       return dict.unwrap;
-  };
+  };                        
+  var newtypeDisj = new Newtype(function (v) {
+      return v;
+  }, Data_Monoid_Disj.Disj);
   var alaF = function (dictFunctor) {
       return function (dictFunctor1) {
           return function (dictNewtype) {
               return function (dictNewtype1) {
                   return function (v) {
                       return function (f) {
-                          return function ($64) {
-                              return Data_Functor.map(dictFunctor1)(unwrap(dictNewtype1))(f(Data_Functor.map(dictFunctor)(wrap(dictNewtype))($64)));
+                          return function ($80) {
+                              return Data_Functor.map(dictFunctor1)(unwrap(dictNewtype1))(f(Data_Functor.map(dictFunctor)(wrap(dictNewtype))($80)));
                           };
                       };
                   };
@@ -518,16 +957,86 @@ var PS = {};
   exports["wrap"] = wrap;
   exports["Newtype"] = Newtype;
   exports["alaF"] = alaF;
+  exports["newtypeDisj"] = newtypeDisj;
 })(PS["Data.Newtype"] = PS["Data.Newtype"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+    "use strict";
+
+  exports.pureE = function (a) {
+    return function () {
+      return a;
+    };
+  };
+
+  exports.bindE = function (a) {
+    return function (f) {
+      return function () {
+        return f(a())();
+      };
+    };
+  };
+})(PS["Effect"] = PS["Effect"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Effect"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Monad = PS["Control.Monad"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Prelude = PS["Prelude"];                 
+  var monadEffect = new Control_Monad.Monad(function () {
+      return applicativeEffect;
+  }, function () {
+      return bindEffect;
+  });
+  var bindEffect = new Control_Bind.Bind(function () {
+      return applyEffect;
+  }, $foreign.bindE);
+  var applyEffect = new Control_Apply.Apply(function () {
+      return functorEffect;
+  }, Control_Monad.ap(monadEffect));
+  var applicativeEffect = new Control_Applicative.Applicative(function () {
+      return applyEffect;
+  }, $foreign.pureE);
+  var functorEffect = new Data_Functor.Functor(Control_Applicative.liftA1(applicativeEffect));
+  exports["functorEffect"] = functorEffect;
+  exports["applyEffect"] = applyEffect;
+  exports["applicativeEffect"] = applicativeEffect;
+  exports["bindEffect"] = bindEffect;
+  exports["monadEffect"] = monadEffect;
+})(PS["Effect"] = PS["Effect"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Category = PS["Control.Category"];
+  var Control_Monad = PS["Control.Monad"];
+  var Effect = PS["Effect"];                 
+  var MonadEffect = function (Monad0, liftEffect) {
+      this.Monad0 = Monad0;
+      this.liftEffect = liftEffect;
+  };
+  var monadEffectEffect = new MonadEffect(function () {
+      return Effect.monadEffect;
+  }, Control_Category.identity(Control_Category.categoryFn));
+  var liftEffect = function (dict) {
+      return dict.liftEffect;
+  };
+  exports["liftEffect"] = liftEffect;
+  exports["MonadEffect"] = MonadEffect;
+  exports["monadEffectEffect"] = monadEffectEffect;
+})(PS["Effect.Class"] = PS["Effect.Class"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
   var Control_Monad = PS["Control.Monad"];
   var Control_Monad_Cont_Class = PS["Control.Monad.Cont.Class"];
-  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
   var Control_Monad_Reader_Class = PS["Control.Monad.Reader.Class"];
   var Control_Monad_State_Class = PS["Control.Monad.State.Class"];
   var Control_Monad_Trans_Class = PS["Control.Monad.Trans.Class"];
@@ -535,6 +1044,7 @@ var PS = {};
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
   var Data_Newtype = PS["Data.Newtype"];
+  var Effect_Class = PS["Effect.Class"];
   var Prelude = PS["Prelude"];
   var runContT = function (v) {
       return function (k) {
@@ -605,1288 +1115,1817 @@ var PS = {};
   exports["monadContT"] = monadContT;
 })(PS["Control.Monad.Cont.Trans"] = PS["Control.Monad.Cont.Trans"] || {});
 (function(exports) {
-    "use strict";
-
-  exports.error = function (s) {
-    return function () {
-      console.error(s);
-      return {};
-    };
-  };
-})(PS["Control.Monad.Eff.Console"] = PS["Control.Monad.Eff.Console"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Control.Monad.Eff.Console"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Data_Show = PS["Data.Show"];
-  var Data_Unit = PS["Data.Unit"];
-  exports["error"] = $foreign.error;
-})(PS["Control.Monad.Eff.Console"] = PS["Control.Monad.Eff.Console"] || {});
-(function(exports) {
-  /* global exports */
+  // Generated by purs version 0.12.0
   "use strict";
-
-  exports.ready = function(func) {
-      return function() {
-          jQuery(document).ready(func);
-      };
+  var Control_Category = PS["Control.Category"];                 
+  var Bifunctor = function (bimap) {
+      this.bimap = bimap;
   };
-
-  exports.select = function(selector) {
-      return function() {
-          return jQuery(selector);
-      };
+  var bimap = function (dict) {
+      return dict.bimap;
   };
-
-  exports.create = function(html) {
-      return function() {
-          return jQuery(html);
+  var lmap = function (dictBifunctor) {
+      return function (f) {
+          return bimap(dictBifunctor)(f)(Control_Category.identity(Control_Category.categoryFn));
       };
   };
+  exports["bimap"] = bimap;
+  exports["Bifunctor"] = Bifunctor;
+  exports["lmap"] = lmap;
+})(PS["Data.Bifunctor"] = PS["Data.Bifunctor"] || {});
+(function(exports) {
+    "use strict";
 
-  exports.setAttr = function(attr) {
-      return function(val) {
-          return function(ob) {
-              return function() {
-                  ob.attr(attr, val);
-              };
-          };
+  exports.foldrArray = function (f) {
+    return function (init) {
+      return function (xs) {
+        var acc = init;
+        var len = xs.length;
+        for (var i = len - 1; i >= 0; i--) {
+          acc = f(xs[i])(acc);
+        }
+        return acc;
       };
+    };
   };
 
-  exports.attr = function(attrs) {
-      return function(ob) {
-          return function() {
-              ob.attr(attrs);
-          };
+  exports.foldlArray = function (f) {
+    return function (init) {
+      return function (xs) {
+        var acc = init;
+        var len = xs.length;
+        for (var i = 0; i < len; i++) {
+          acc = f(acc)(xs[i]);
+        }
+        return acc;
       };
+    };
   };
-
-  exports.toggleClass = function(cls) {
-      return function(ob) {
-          return function() {
-              ob.toggleClass(cls);
-          };
-      };
+})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Alt = PS["Control.Alt"];
+  var Data_Functor = PS["Data.Functor"];                 
+  var Plus = function (Alt0, empty) {
+      this.Alt0 = Alt0;
+      this.empty = empty;
+  };       
+  var empty = function (dict) {
+      return dict.empty;
   };
+  exports["Plus"] = Plus;
+  exports["empty"] = empty;
+})(PS["Control.Plus"] = PS["Control.Plus"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Alt = PS["Control.Alt"];
+  var Control_Alternative = PS["Control.Alternative"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Extend = PS["Control.Extend"];
+  var Control_Monad = PS["Control.Monad"];
+  var Control_MonadZero = PS["Control.MonadZero"];
+  var Control_Plus = PS["Control.Plus"];
+  var Data_Bounded = PS["Data.Bounded"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
+  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ordering = PS["Data.Ordering"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Show = PS["Data.Show"];
+  var Data_Unit = PS["Data.Unit"];
+  var Prelude = PS["Prelude"];                 
+  var Nothing = (function () {
+      function Nothing() {
 
-  exports.setClass = function(cls) {
-      return function(flag) {
-          return function(ob) {
-              return function() {
-                  ob.toggleClass(cls, flag);
-              };
-          };
       };
-  };
-
-  exports.setProp = function(p) {
-      return function(val) {
-          return function(ob) {
-              return function() {
-                  ob.prop(p, val);
-              };
-          };
+      Nothing.value = new Nothing();
+      return Nothing;
+  })();
+  var Just = (function () {
+      function Just(value0) {
+          this.value0 = value0;
       };
-  };
-
-  exports.append = function(ob1) {
-      return function(ob) {
-          return function() {
-              ob.append(ob1);
-          };
+      Just.create = function (value0) {
+          return new Just(value0);
       };
-  };
-
-  exports.setText = function(text) {
-      return function(ob) {
-          return function() {
-              ob.text(text);
+      return Just;
+  })();
+  var maybe = function (v) {
+      return function (v1) {
+          return function (v2) {
+              if (v2 instanceof Nothing) {
+                  return v;
+              };
+              if (v2 instanceof Just) {
+                  return v1(v2.value0);
+              };
+              throw new Error("Failed pattern match at Data.Maybe line 218, column 1 - line 218, column 51: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
           };
       };
   };
-
-  exports.setValue = function(val) {
-      return function(ob) {
-          return function() {
-              ob.val(val);
+  var isNothing = maybe(true)(Data_Function["const"](false));
+  var functorMaybe = new Data_Functor.Functor(function (v) {
+      return function (v1) {
+          if (v1 instanceof Just) {
+              return new Just(v(v1.value0));
           };
+          return Nothing.value;
       };
+  });
+  var fromMaybe = function (a) {
+      return maybe(a)(Control_Category.identity(Control_Category.categoryFn));
   };
-
-  exports.toggle = function(ob) {
-      return function() {
-          ob.toggle();
+  var fromJust = function (dictPartial) {
+      return function (v) {
+          var $__unused = function (dictPartial1) {
+              return function ($dollar35) {
+                  return $dollar35;
+              };
+          };
+          return $__unused(dictPartial)((function () {
+              if (v instanceof Just) {
+                  return v.value0;
+              };
+              throw new Error("Failed pattern match at Data.Maybe line 269, column 1 - line 269, column 46: " + [ v.constructor.name ]);
+          })());
       };
   };
-
-  exports.setVisible = function(flag) {
-      return function(ob) {
-          return function() {
-              ob.toggle(flag);
-          };
-      };
+  exports["Nothing"] = Nothing;
+  exports["Just"] = Just;
+  exports["maybe"] = maybe;
+  exports["fromMaybe"] = fromMaybe;
+  exports["isNothing"] = isNothing;
+  exports["fromJust"] = fromJust;
+  exports["functorMaybe"] = functorMaybe;
+})(PS["Data.Maybe"] = PS["Data.Maybe"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Foldable"];
+  var Control_Alt = PS["Control.Alt"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Plus = PS["Control.Plus"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Maybe_First = PS["Data.Maybe.First"];
+  var Data_Maybe_Last = PS["Data.Maybe.Last"];
+  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
+  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
+  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
+  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
+  var Data_Monoid_Endo = PS["Data.Monoid.Endo"];
+  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
+  var Data_Newtype = PS["Data.Newtype"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ordering = PS["Data.Ordering"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Unit = PS["Data.Unit"];
+  var Prelude = PS["Prelude"];                 
+  var Foldable = function (foldMap, foldl, foldr) {
+      this.foldMap = foldMap;
+      this.foldl = foldl;
+      this.foldr = foldr;
   };
-
-  exports.on = function(evt) {
-      return function(act) {
-          return function(ob) {
-              return function() {
-                  ob.on(evt, function(e) {
-                      act(e)(jQuery(this))();
-                  });
-              };
+  var foldr = function (dict) {
+      return dict.foldr;
+  };
+  var traverse_ = function (dictApplicative) {
+      return function (dictFoldable) {
+          return function (f) {
+              return foldr(dictFoldable)(function ($195) {
+                  return Control_Apply.applySecond(dictApplicative.Apply0())(f($195));
+              })(Control_Applicative.pure(dictApplicative)(Data_Unit.unit));
           };
       };
   };
-})(PS["Control.Monad.Eff.JQuery"] = PS["Control.Monad.Eff.JQuery"] || {});
-(function(exports) {
-    "use strict";
-
-  exports.unsafeFromForeign = function (value) {
-    return value;
-  };
-
-  exports.typeOf = function (value) {
-    return typeof value;
-  };
-
-  exports.tagOf = function (value) {
-    return Object.prototype.toString.call(value).slice(8, -1);
+  var for_ = function (dictApplicative) {
+      return function (dictFoldable) {
+          return Data_Function.flip(traverse_(dictApplicative)(dictFoldable));
+      };
   };
-
-  exports.isNull = function (value) {
-    return value === null;
+  var foldl = function (dict) {
+      return dict.foldl;
   };
-
-  exports.isUndefined = function (value) {
-    return value === undefined;
+  var intercalate = function (dictFoldable) {
+      return function (dictMonoid) {
+          return function (sep) {
+              return function (xs) {
+                  var go = function (v) {
+                      return function (x) {
+                          if (v.init) {
+                              return {
+                                  init: false,
+                                  acc: x
+                              };
+                          };
+                          return {
+                              init: false,
+                              acc: Data_Semigroup.append(dictMonoid.Semigroup0())(v.acc)(Data_Semigroup.append(dictMonoid.Semigroup0())(sep)(x))
+                          };
+                      };
+                  };
+                  return (foldl(dictFoldable)(go)({
+                      init: true,
+                      acc: Data_Monoid.mempty(dictMonoid)
+                  })(xs)).acc;
+              };
+          };
+      };
+  }; 
+  var foldableMaybe = new Foldable(function (dictMonoid) {
+      return function (f) {
+          return function (v) {
+              if (v instanceof Data_Maybe.Nothing) {
+                  return Data_Monoid.mempty(dictMonoid);
+              };
+              if (v instanceof Data_Maybe.Just) {
+                  return f(v.value0);
+              };
+              throw new Error("Failed pattern match at Data.Foldable line 129, column 1 - line 129, column 41: " + [ f.constructor.name, v.constructor.name ]);
+          };
+      };
+  }, function (v) {
+      return function (z) {
+          return function (v1) {
+              if (v1 instanceof Data_Maybe.Nothing) {
+                  return z;
+              };
+              if (v1 instanceof Data_Maybe.Just) {
+                  return v(z)(v1.value0);
+              };
+              throw new Error("Failed pattern match at Data.Foldable line 129, column 1 - line 129, column 41: " + [ v.constructor.name, z.constructor.name, v1.constructor.name ]);
+          };
+      };
+  }, function (v) {
+      return function (z) {
+          return function (v1) {
+              if (v1 instanceof Data_Maybe.Nothing) {
+                  return z;
+              };
+              if (v1 instanceof Data_Maybe.Just) {
+                  return v(v1.value0)(z);
+              };
+              throw new Error("Failed pattern match at Data.Foldable line 129, column 1 - line 129, column 41: " + [ v.constructor.name, z.constructor.name, v1.constructor.name ]);
+          };
+      };
+  });
+  var foldMapDefaultR = function (dictFoldable) {
+      return function (dictMonoid) {
+          return function (f) {
+              return foldr(dictFoldable)(function (x) {
+                  return function (acc) {
+                      return Data_Semigroup.append(dictMonoid.Semigroup0())(f(x))(acc);
+                  };
+              })(Data_Monoid.mempty(dictMonoid));
+          };
+      };
   };
-
-  exports.isArray = Array.isArray || function (value) {
-    return Object.prototype.toString.call(value) === "[object Array]";
+  var foldableArray = new Foldable(function (dictMonoid) {
+      return foldMapDefaultR(foldableArray)(dictMonoid);
+  }, $foreign.foldlArray, $foreign.foldrArray);
+  var foldMap = function (dict) {
+      return dict.foldMap;
   };
-})(PS["Data.Foreign"] = PS["Data.Foreign"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Control_Category = PS["Control.Category"];        
-  var Bifunctor = function (bimap) {
-      this.bimap = bimap;
+  var fold = function (dictFoldable) {
+      return function (dictMonoid) {
+          return foldMap(dictFoldable)(dictMonoid)(Control_Category.identity(Control_Category.categoryFn));
+      };
   };
-  var bimap = function (dict) {
-      return dict.bimap;
+  var any = function (dictFoldable) {
+      return function (dictHeytingAlgebra) {
+          return Data_Newtype.alaF(Data_Functor.functorFn)(Data_Functor.functorFn)(Data_Newtype.newtypeDisj)(Data_Newtype.newtypeDisj)(Data_Monoid_Disj.Disj)(foldMap(dictFoldable)(Data_Monoid_Disj.monoidDisj(dictHeytingAlgebra)));
+      };
   };
-  var lmap = function (dictBifunctor) {
-      return function (f) {
-          return bimap(dictBifunctor)(f)(Control_Category.id(Control_Category.categoryFn));
+  var elem = function (dictFoldable) {
+      return function (dictEq) {
+          return function ($199) {
+              return any(dictFoldable)(Data_HeytingAlgebra.heytingAlgebraBoolean)(Data_Eq.eq(dictEq)($199));
+          };
       };
   };
-  exports["bimap"] = bimap;
-  exports["Bifunctor"] = Bifunctor;
-  exports["lmap"] = lmap;
-})(PS["Data.Bifunctor"] = PS["Data.Bifunctor"] || {});
-(function(exports) {
-    "use strict";
-
-  exports.topInt = 2147483647;
-  exports.bottomInt = -2147483648;
-})(PS["Data.Bounded"] = PS["Data.Bounded"] || {});
+  exports["Foldable"] = Foldable;
+  exports["foldr"] = foldr;
+  exports["foldl"] = foldl;
+  exports["foldMap"] = foldMap;
+  exports["foldMapDefaultR"] = foldMapDefaultR;
+  exports["fold"] = fold;
+  exports["traverse_"] = traverse_;
+  exports["for_"] = for_;
+  exports["intercalate"] = intercalate;
+  exports["any"] = any;
+  exports["elem"] = elem;
+  exports["foldableArray"] = foldableArray;
+  exports["foldableMaybe"] = foldableMaybe;
+})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
 (function(exports) {
     "use strict";
 
-  exports.refEq = function (r1) {
-    return function (r2) {
-      return r1 === r2;
+  exports.mapWithIndexArray = function (f) {
+    return function (xs) {
+      var l = xs.length;
+      var result = Array(l);
+      for (var i = 0; i < l; i++) {
+        result[i] = f(i)(xs[i]);
+      }
+      return result;
     };
   };
-})(PS["Data.Eq"] = PS["Data.Eq"] || {});
+})(PS["Data.FunctorWithIndex"] = PS["Data.FunctorWithIndex"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.Eq"];
+  var $foreign = PS["Data.FunctorWithIndex"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Maybe_First = PS["Data.Maybe.First"];
+  var Data_Maybe_Last = PS["Data.Maybe.Last"];
+  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
+  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
+  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
+  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
+  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
   var Data_Unit = PS["Data.Unit"];
-  var Data_Void = PS["Data.Void"];        
-  var Eq = function (eq) {
-      this.eq = eq;
-  }; 
-  var eqString = new Eq($foreign.refEq);
-  var eqInt = new Eq($foreign.refEq);
-  var eq = function (dict) {
-      return dict.eq;
+  var Prelude = PS["Prelude"];                 
+  var FunctorWithIndex = function (Functor0, mapWithIndex) {
+      this.Functor0 = Functor0;
+      this.mapWithIndex = mapWithIndex;
   };
-  exports["Eq"] = Eq;
-  exports["eq"] = eq;
-  exports["eqInt"] = eqInt;
-  exports["eqString"] = eqString;
-})(PS["Data.Eq"] = PS["Data.Eq"] || {});
-(function(exports) {
-    "use strict";
-
-  exports.unsafeCompareImpl = function (lt) {
-    return function (eq) {
-      return function (gt) {
-        return function (x) {
-          return function (y) {
-            return x < y ? lt : x === y ? eq : gt;
-          };
-        };
-      };
-    };
-  };
-})(PS["Data.Ord.Unsafe"] = PS["Data.Ord.Unsafe"] || {});
+  var mapWithIndex = function (dict) {
+      return dict.mapWithIndex;
+  }; 
+  var functorWithIndexArray = new FunctorWithIndex(function () {
+      return Data_Functor.functorArray;
+  }, $foreign.mapWithIndexArray);
+  exports["FunctorWithIndex"] = FunctorWithIndex;
+  exports["mapWithIndex"] = mapWithIndex;
+  exports["functorWithIndexArray"] = functorWithIndexArray;
+})(PS["Data.FunctorWithIndex"] = PS["Data.FunctorWithIndex"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Data_Eq = PS["Data.Eq"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_Function = PS["Data.Function"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Maybe_First = PS["Data.Maybe.First"];
+  var Data_Maybe_Last = PS["Data.Maybe.Last"];
+  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
+  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
+  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
+  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
+  var Data_Monoid_Endo = PS["Data.Monoid.Endo"];
+  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
+  var Data_Newtype = PS["Data.Newtype"];
   var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Show = PS["Data.Show"];        
-  var LT = (function () {
-      function LT() {
-
+  var Data_Unit = PS["Data.Unit"];
+  var Prelude = PS["Prelude"];                 
+  var Tuple = (function () {
+      function Tuple(value0, value1) {
+          this.value0 = value0;
+          this.value1 = value1;
       };
-      LT.value = new LT();
-      return LT;
-  })();
-  var GT = (function () {
-      function GT() {
-
+      Tuple.create = function (value0) {
+          return function (value1) {
+              return new Tuple(value0, value1);
+          };
       };
-      GT.value = new GT();
-      return GT;
+      return Tuple;
   })();
-  var EQ = (function () {
-      function EQ() {
-
+  var FoldableWithIndex = function (Foldable0, foldMapWithIndex, foldlWithIndex, foldrWithIndex) {
+      this.Foldable0 = Foldable0;
+      this.foldMapWithIndex = foldMapWithIndex;
+      this.foldlWithIndex = foldlWithIndex;
+      this.foldrWithIndex = foldrWithIndex;
+  };
+  var foldrWithIndex = function (dict) {
+      return dict.foldrWithIndex;
+  };
+  var traverseWithIndex_ = function (dictApplicative) {
+      return function (dictFoldableWithIndex) {
+          return function (f) {
+              return foldrWithIndex(dictFoldableWithIndex)(function (i) {
+                  return function ($46) {
+                      return Control_Apply.applySecond(dictApplicative.Apply0())(f(i)($46));
+                  };
+              })(Control_Applicative.pure(dictApplicative)(Data_Unit.unit));
+          };
       };
-      EQ.value = new EQ();
-      return EQ;
-  })();
-  exports["LT"] = LT;
-  exports["GT"] = GT;
-  exports["EQ"] = EQ;
-})(PS["Data.Ordering"] = PS["Data.Ordering"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Data.Ord.Unsafe"];
-  var Data_Ordering = PS["Data.Ordering"];        
-  var unsafeCompare = $foreign.unsafeCompareImpl(Data_Ordering.LT.value)(Data_Ordering.EQ.value)(Data_Ordering.GT.value);
-  exports["unsafeCompare"] = unsafeCompare;
-})(PS["Data.Ord.Unsafe"] = PS["Data.Ord.Unsafe"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Data.Ord"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Ord_Unsafe = PS["Data.Ord.Unsafe"];
-  var Data_Ordering = PS["Data.Ordering"];
-  var Data_Ring = PS["Data.Ring"];
-  var Data_Semiring = PS["Data.Semiring"];
-  var Data_Unit = PS["Data.Unit"];
-  var Data_Void = PS["Data.Void"];        
-  var Ord = function (Eq0, compare) {
-      this.Eq0 = Eq0;
-      this.compare = compare;
-  };                                
-  var ordInt = new Ord(function () {
-      return Data_Eq.eqInt;
-  }, Data_Ord_Unsafe.unsafeCompare);
-  var compare = function (dict) {
-      return dict.compare;
   };
-  exports["Ord"] = Ord;
-  exports["compare"] = compare;
-  exports["ordInt"] = ordInt;
-})(PS["Data.Ord"] = PS["Data.Ord"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Data.Bounded"];
-  var Data_Ord = PS["Data.Ord"];
-  var Data_Ordering = PS["Data.Ordering"];
-  var Data_Unit = PS["Data.Unit"];        
-  var Bounded = function (Ord0, bottom, top) {
-      this.Ord0 = Ord0;
-      this.bottom = bottom;
-      this.top = top;
+  var forWithIndex_ = function (dictApplicative) {
+      return function (dictFoldableWithIndex) {
+          return Data_Function.flip(traverseWithIndex_(dictApplicative)(dictFoldableWithIndex));
+      };
   };
-  var top = function (dict) {
-      return dict.top;
-  };                                                 
-  var boundedInt = new Bounded(function () {
-      return Data_Ord.ordInt;
-  }, $foreign.bottomInt, $foreign.topInt);
-  var bottom = function (dict) {
-      return dict.bottom;
+  var foldlWithIndex = function (dict) {
+      return dict.foldlWithIndex;
   };
-  exports["Bounded"] = Bounded;
-  exports["bottom"] = bottom;
-  exports["top"] = top;
-  exports["boundedInt"] = boundedInt;
-})(PS["Data.Bounded"] = PS["Data.Bounded"] || {});
+  var foldMapWithIndexDefaultR = function (dictFoldableWithIndex) {
+      return function (dictMonoid) {
+          return function (f) {
+              return foldrWithIndex(dictFoldableWithIndex)(function (i) {
+                  return function (x) {
+                      return function (acc) {
+                          return Data_Semigroup.append(dictMonoid.Semigroup0())(f(i)(x))(acc);
+                      };
+                  };
+              })(Data_Monoid.mempty(dictMonoid));
+          };
+      };
+  };
+  var foldableWithIndexArray = new FoldableWithIndex(function () {
+      return Data_Foldable.foldableArray;
+  }, function (dictMonoid) {
+      return foldMapWithIndexDefaultR(foldableWithIndexArray)(dictMonoid);
+  }, function (f) {
+      return function (z) {
+          return function ($47) {
+              return Data_Foldable.foldl(Data_Foldable.foldableArray)(function (y) {
+                  return function (v) {
+                      return f(v.value0)(y)(v.value1);
+                  };
+              })(z)(Data_FunctorWithIndex.mapWithIndex(Data_FunctorWithIndex.functorWithIndexArray)(Tuple.create)($47));
+          };
+      };
+  }, function (f) {
+      return function (z) {
+          return function ($48) {
+              return Data_Foldable.foldr(Data_Foldable.foldableArray)(function (v) {
+                  return function (y) {
+                      return f(v.value0)(v.value1)(y);
+                  };
+              })(z)(Data_FunctorWithIndex.mapWithIndex(Data_FunctorWithIndex.functorWithIndexArray)(Tuple.create)($48));
+          };
+      };
+  });
+  var foldMapWithIndex = function (dict) {
+      return dict.foldMapWithIndex;
+  };
+  exports["FoldableWithIndex"] = FoldableWithIndex;
+  exports["foldrWithIndex"] = foldrWithIndex;
+  exports["foldlWithIndex"] = foldlWithIndex;
+  exports["foldMapWithIndex"] = foldMapWithIndex;
+  exports["foldMapWithIndexDefaultR"] = foldMapWithIndexDefaultR;
+  exports["traverseWithIndex_"] = traverseWithIndex_;
+  exports["forWithIndex_"] = forWithIndex_;
+  exports["foldableWithIndexArray"] = foldableWithIndexArray;
+})(PS["Data.FoldableWithIndex"] = PS["Data.FoldableWithIndex"] || {});
 (function(exports) {
     "use strict";
 
-  exports.foldrArray = function (f) {
-    return function (init) {
-      return function (xs) {
-        var acc = init;
-        var len = xs.length;
-        for (var i = len - 1; i >= 0; i--) {
-          acc = f(xs[i])(acc);
-        }
-        return acc;
+  // jshint maxparams: 3
+
+  exports.traverseArrayImpl = function () {
+    function array1(a) {
+      return [a];
+    }
+
+    function array2(a) {
+      return function (b) {
+        return [a, b];
       };
-    };
-  };
+    }
 
-  exports.foldlArray = function (f) {
-    return function (init) {
-      return function (xs) {
-        var acc = init;
-        var len = xs.length;
-        for (var i = 0; i < len; i++) {
-          acc = f(acc)(xs[i]);
-        }
-        return acc;
+    function array3(a) {
+      return function (b) {
+        return function (c) {
+          return [a, b, c];
+        };
+      };
+    }
+
+    function concat2(xs) {
+      return function (ys) {
+        return xs.concat(ys);
+      };
+    }
+
+    return function (apply) {
+      return function (map) {
+        return function (pure) {
+          return function (f) {
+            return function (array) {
+              function go(bot, top) {
+                switch (top - bot) {
+                case 0: return pure([]);
+                case 1: return map(array1)(f(array[bot]));
+                case 2: return apply(map(array2)(f(array[bot])))(f(array[bot + 1]));
+                case 3: return apply(apply(map(array3)(f(array[bot])))(f(array[bot + 1])))(f(array[bot + 2]));
+                default:
+                  // This slightly tricky pivot selection aims to produce two
+                  // even-length partitions where possible.
+                  var pivot = bot + Math.floor((top - bot) / 4) * 2;
+                  return apply(map(concat2)(go(bot, pivot)))(go(pivot, top));
+                }
+              }
+              return go(0, array.length);
+            };
+          };
+        };
       };
     };
-  };
-})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
+  }();
+})(PS["Data.Traversable"] = PS["Data.Traversable"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Alt = PS["Control.Alt"];
-  var Data_Functor = PS["Data.Functor"];        
-  var Plus = function (Alt0, empty) {
-      this.Alt0 = Alt0;
-      this.empty = empty;
-  };       
-  var empty = function (dict) {
-      return dict.empty;
-  };
-  exports["Plus"] = Plus;
-  exports["empty"] = empty;
-})(PS["Control.Plus"] = PS["Control.Plus"] || {});
+  var $foreign = PS["Data.Traversable"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Category = PS["Control.Category"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Maybe_First = PS["Data.Maybe.First"];
+  var Data_Maybe_Last = PS["Data.Maybe.Last"];
+  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
+  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
+  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
+  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
+  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
+  var Data_Traversable_Accum = PS["Data.Traversable.Accum"];
+  var Data_Traversable_Accum_Internal = PS["Data.Traversable.Accum.Internal"];
+  var Prelude = PS["Prelude"];                 
+  var Traversable = function (Foldable1, Functor0, sequence, traverse) {
+      this.Foldable1 = Foldable1;
+      this.Functor0 = Functor0;
+      this.sequence = sequence;
+      this.traverse = traverse;
+  };
+  var traverse = function (dict) {
+      return dict.traverse;
+  }; 
+  var sequenceDefault = function (dictTraversable) {
+      return function (dictApplicative) {
+          return traverse(dictTraversable)(dictApplicative)(Control_Category.identity(Control_Category.categoryFn));
+      };
+  };
+  var traversableArray = new Traversable(function () {
+      return Data_Foldable.foldableArray;
+  }, function () {
+      return Data_Functor.functorArray;
+  }, function (dictApplicative) {
+      return sequenceDefault(traversableArray)(dictApplicative);
+  }, function (dictApplicative) {
+      return $foreign.traverseArrayImpl(Control_Apply.apply(dictApplicative.Apply0()))(Data_Functor.map((dictApplicative.Apply0()).Functor0()))(Control_Applicative.pure(dictApplicative));
+  });
+  var sequence = function (dict) {
+      return dict.sequence;
+  };
+  exports["Traversable"] = Traversable;
+  exports["traverse"] = traverse;
+  exports["sequence"] = sequence;
+  exports["sequenceDefault"] = sequenceDefault;
+  exports["traversableArray"] = traversableArray;
+})(PS["Data.Traversable"] = PS["Data.Traversable"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Alt = PS["Control.Alt"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Extend = PS["Control.Extend"];
+  var Control_Monad = PS["Control.Monad"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Bifoldable = PS["Data.Bifoldable"];
+  var Data_Bifunctor = PS["Data.Bifunctor"];
+  var Data_Bitraversable = PS["Data.Bitraversable"];
+  var Data_Bounded = PS["Data.Bounded"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ordering = PS["Data.Ordering"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Show = PS["Data.Show"];
+  var Data_Traversable = PS["Data.Traversable"];
+  var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
+  var Data_Unit = PS["Data.Unit"];
+  var Prelude = PS["Prelude"];                 
+  var Left = (function () {
+      function Left(value0) {
+          this.value0 = value0;
+      };
+      Left.create = function (value0) {
+          return new Left(value0);
+      };
+      return Left;
+  })();
+  var Right = (function () {
+      function Right(value0) {
+          this.value0 = value0;
+      };
+      Right.create = function (value0) {
+          return new Right(value0);
+      };
+      return Right;
+  })();
+  var functorEither = new Data_Functor.Functor(function (f) {
+      return function (m) {
+          if (m instanceof Left) {
+              return new Left(m.value0);
+          };
+          if (m instanceof Right) {
+              return new Right(f(m.value0));
+          };
+          throw new Error("Failed pattern match at Data.Either line 38, column 8 - line 38, column 52: " + [ m.constructor.name ]);
+      };
+  });                                                                                                     
+  var fromRight = function (dictPartial) {
+      return function (v) {
+          var $__unused = function (dictPartial1) {
+              return function ($dollar71) {
+                  return $dollar71;
+              };
+          };
+          return $__unused(dictPartial)((function () {
+              if (v instanceof Right) {
+                  return v.value0;
+              };
+              throw new Error("Failed pattern match at Data.Either line 261, column 1 - line 261, column 52: " + [ v.constructor.name ]);
+          })());
+      };
+  };
+  var either = function (v) {
+      return function (v1) {
+          return function (v2) {
+              if (v2 instanceof Left) {
+                  return v(v2.value0);
+              };
+              if (v2 instanceof Right) {
+                  return v1(v2.value0);
+              };
+              throw new Error("Failed pattern match at Data.Either line 238, column 1 - line 238, column 64: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
+          };
+      };
+  };
+  var bifunctorEither = new Data_Bifunctor.Bifunctor(function (v) {
+      return function (v1) {
+          return function (v2) {
+              if (v2 instanceof Left) {
+                  return new Left(v(v2.value0));
+              };
+              if (v2 instanceof Right) {
+                  return new Right(v1(v2.value0));
+              };
+              throw new Error("Failed pattern match at Data.Either line 46, column 1 - line 46, column 45: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
+          };
+      };
+  });
+  var applyEither = new Control_Apply.Apply(function () {
+      return functorEither;
+  }, function (v) {
+      return function (v1) {
+          if (v instanceof Left) {
+              return new Left(v.value0);
+          };
+          if (v instanceof Right) {
+              return Data_Functor.map(functorEither)(v.value0)(v1);
+          };
+          throw new Error("Failed pattern match at Data.Either line 82, column 1 - line 82, column 41: " + [ v.constructor.name, v1.constructor.name ]);
+      };
+  });
+  var applicativeEither = new Control_Applicative.Applicative(function () {
+      return applyEither;
+  }, Right.create);
+  exports["Left"] = Left;
+  exports["Right"] = Right;
+  exports["either"] = either;
+  exports["fromRight"] = fromRight;
+  exports["functorEither"] = functorEither;
+  exports["bifunctorEither"] = bifunctorEither;
+  exports["applyEither"] = applyEither;
+  exports["applicativeEither"] = applicativeEither;
+})(PS["Data.Either"] = PS["Data.Either"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Either = PS["Data.Either"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Unit = PS["Data.Unit"];
+  var Prelude = PS["Prelude"];                 
+  var MonadThrow = function (Monad0, throwError) {
+      this.Monad0 = Monad0;
+      this.throwError = throwError;
+  };
+  var throwError = function (dict) {
+      return dict.throwError;
+  };
+  exports["throwError"] = throwError;
+  exports["MonadThrow"] = MonadThrow;
+})(PS["Control.Monad.Error.Class"] = PS["Control.Monad.Error.Class"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Biapplicative = PS["Control.Biapplicative"];
+  var Control_Biapply = PS["Control.Biapply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Comonad = PS["Control.Comonad"];
+  var Control_Extend = PS["Control.Extend"];
+  var Control_Lazy = PS["Control.Lazy"];
+  var Control_Monad = PS["Control.Monad"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Bifoldable = PS["Data.Bifoldable"];
+  var Data_Bifunctor = PS["Data.Bifunctor"];
+  var Data_Bitraversable = PS["Data.Bitraversable"];
+  var Data_BooleanAlgebra = PS["Data.BooleanAlgebra"];
+  var Data_Bounded = PS["Data.Bounded"];
+  var Data_CommutativeRing = PS["Data.CommutativeRing"];
+  var Data_Distributive = PS["Data.Distributive"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Maybe_First = PS["Data.Maybe.First"];
+  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Newtype = PS["Data.Newtype"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ordering = PS["Data.Ordering"];
+  var Data_Ring = PS["Data.Ring"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Semigroup_Foldable = PS["Data.Semigroup.Foldable"];
+  var Data_Semigroup_Traversable = PS["Data.Semigroup.Traversable"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Show = PS["Data.Show"];
+  var Data_Traversable = PS["Data.Traversable"];
+  var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
+  var Data_Unit = PS["Data.Unit"];
+  var Prelude = PS["Prelude"];
+  var Type_Equality = PS["Type.Equality"];                 
+  var Tuple = (function () {
+      function Tuple(value0, value1) {
+          this.value0 = value0;
+          this.value1 = value1;
+      };
+      Tuple.create = function (value0) {
+          return function (value1) {
+              return new Tuple(value0, value1);
+          };
+      };
+      return Tuple;
+  })();
+  var snd = function (v) {
+      return v.value1;
+  };                                                                                                    
+  var fst = function (v) {
+      return v.value0;
+  };
+  exports["Tuple"] = Tuple;
+  exports["fst"] = fst;
+  exports["snd"] = snd;
+})(PS["Data.Tuple"] = PS["Data.Tuple"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Alt = PS["Control.Alt"];
+  var Control_Alternative = PS["Control.Alternative"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Monad = PS["Control.Monad"];
+  var Control_Monad_Cont_Class = PS["Control.Monad.Cont.Class"];
+  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
+  var Control_Monad_Reader_Class = PS["Control.Monad.Reader.Class"];
+  var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
+  var Control_Monad_State_Class = PS["Control.Monad.State.Class"];
+  var Control_Monad_Trans_Class = PS["Control.Monad.Trans.Class"];
+  var Control_Monad_Writer_Class = PS["Control.Monad.Writer.Class"];
+  var Control_MonadPlus = PS["Control.MonadPlus"];
+  var Control_MonadZero = PS["Control.MonadZero"];
+  var Control_Plus = PS["Control.Plus"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Either = PS["Data.Either"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Newtype = PS["Data.Newtype"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Effect_Class = PS["Effect.Class"];
+  var Prelude = PS["Prelude"];                 
+  var ExceptT = function (x) {
+      return x;
+  };
+  var runExceptT = function (v) {
+      return v;
+  }; 
+  var mapExceptT = function (f) {
+      return function (v) {
+          return f(v);
+      };
+  };
+  var functorExceptT = function (dictFunctor) {
+      return new Data_Functor.Functor(function (f) {
+          return mapExceptT(Data_Functor.map(dictFunctor)(Data_Functor.map(Data_Either.functorEither)(f)));
+      });
+  };
+  var monadExceptT = function (dictMonad) {
+      return new Control_Monad.Monad(function () {
+          return applicativeExceptT(dictMonad);
+      }, function () {
+          return bindExceptT(dictMonad);
+      });
+  };
+  var bindExceptT = function (dictMonad) {
+      return new Control_Bind.Bind(function () {
+          return applyExceptT(dictMonad);
+      }, function (v) {
+          return function (k) {
+              return Control_Bind.bind(dictMonad.Bind1())(v)(Data_Either.either(function ($97) {
+                  return Control_Applicative.pure(dictMonad.Applicative0())(Data_Either.Left.create($97));
+              })(function (a) {
+                  var v1 = k(a);
+                  return v1;
+              }));
+          };
+      });
+  };
+  var applyExceptT = function (dictMonad) {
+      return new Control_Apply.Apply(function () {
+          return functorExceptT(((dictMonad.Bind1()).Apply0()).Functor0());
+      }, Control_Monad.ap(monadExceptT(dictMonad)));
+  };
+  var applicativeExceptT = function (dictMonad) {
+      return new Control_Applicative.Applicative(function () {
+          return applyExceptT(dictMonad);
+      }, function ($98) {
+          return ExceptT(Control_Applicative.pure(dictMonad.Applicative0())(Data_Either.Right.create($98)));
+      });
+  };
+  var monadThrowExceptT = function (dictMonad) {
+      return new Control_Monad_Error_Class.MonadThrow(function () {
+          return monadExceptT(dictMonad);
+      }, function ($102) {
+          return ExceptT(Control_Applicative.pure(dictMonad.Applicative0())(Data_Either.Left.create($102)));
+      });
+  };
+  var altExceptT = function (dictSemigroup) {
+      return function (dictMonad) {
+          return new Control_Alt.Alt(function () {
+              return functorExceptT(((dictMonad.Bind1()).Apply0()).Functor0());
+          }, function (v) {
+              return function (v1) {
+                  return Control_Bind.bind(dictMonad.Bind1())(v)(function (v2) {
+                      if (v2 instanceof Data_Either.Right) {
+                          return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Either.Right(v2.value0));
+                      };
+                      if (v2 instanceof Data_Either.Left) {
+                          return Control_Bind.bind(dictMonad.Bind1())(v1)(function (v3) {
+                              if (v3 instanceof Data_Either.Right) {
+                                  return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Either.Right(v3.value0));
+                              };
+                              if (v3 instanceof Data_Either.Left) {
+                                  return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Either.Left(Data_Semigroup.append(dictSemigroup)(v2.value0)(v3.value0)));
+                              };
+                              throw new Error("Failed pattern match at Control.Monad.Except.Trans line 86, column 9 - line 88, column 49: " + [ v3.constructor.name ]);
+                          });
+                      };
+                      throw new Error("Failed pattern match at Control.Monad.Except.Trans line 82, column 5 - line 88, column 49: " + [ v2.constructor.name ]);
+                  });
+              };
+          });
+      };
+  };
+  exports["ExceptT"] = ExceptT;
+  exports["runExceptT"] = runExceptT;
+  exports["mapExceptT"] = mapExceptT;
+  exports["functorExceptT"] = functorExceptT;
+  exports["applyExceptT"] = applyExceptT;
+  exports["applicativeExceptT"] = applicativeExceptT;
+  exports["bindExceptT"] = bindExceptT;
+  exports["monadExceptT"] = monadExceptT;
+  exports["altExceptT"] = altExceptT;
+  exports["monadThrowExceptT"] = monadThrowExceptT;
+})(PS["Control.Monad.Except.Trans"] = PS["Control.Monad.Except.Trans"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Alt = PS["Control.Alt"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Comonad = PS["Control.Comonad"];
+  var Control_Extend = PS["Control.Extend"];
+  var Control_Lazy = PS["Control.Lazy"];
+  var Control_Monad = PS["Control.Monad"];
+  var Data_BooleanAlgebra = PS["Data.BooleanAlgebra"];
+  var Data_Bounded = PS["Data.Bounded"];
+  var Data_CommutativeRing = PS["Data.CommutativeRing"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_EuclideanRing = PS["Data.EuclideanRing"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Newtype = PS["Data.Newtype"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ring = PS["Data.Ring"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Semigroup_Foldable = PS["Data.Semigroup.Foldable"];
+  var Data_Semigroup_Traversable = PS["Data.Semigroup.Traversable"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Show = PS["Data.Show"];
+  var Data_Traversable = PS["Data.Traversable"];
+  var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
+  var Data_Unit = PS["Data.Unit"];
+  var Prelude = PS["Prelude"];                 
+  var Identity = function (x) {
+      return x;
+  };
+  var newtypeIdentity = new Data_Newtype.Newtype(function (n) {
+      return n;
+  }, Identity);
+  var functorIdentity = new Data_Functor.Functor(function (f) {
+      return function (m) {
+          return f(m);
+      };
+  });
+  var applyIdentity = new Control_Apply.Apply(function () {
+      return functorIdentity;
+  }, function (v) {
+      return function (v1) {
+          return v(v1);
+      };
+  });
+  var bindIdentity = new Control_Bind.Bind(function () {
+      return applyIdentity;
+  }, function (v) {
+      return function (f) {
+          return f(v);
+      };
+  });
+  var applicativeIdentity = new Control_Applicative.Applicative(function () {
+      return applyIdentity;
+  }, Identity);
+  var monadIdentity = new Control_Monad.Monad(function () {
+      return applicativeIdentity;
+  }, function () {
+      return bindIdentity;
+  });
+  exports["Identity"] = Identity;
+  exports["newtypeIdentity"] = newtypeIdentity;
+  exports["functorIdentity"] = functorIdentity;
+  exports["applyIdentity"] = applyIdentity;
+  exports["applicativeIdentity"] = applicativeIdentity;
+  exports["bindIdentity"] = bindIdentity;
+  exports["monadIdentity"] = monadIdentity;
+})(PS["Data.Identity"] = PS["Data.Identity"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
+  var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Either = PS["Data.Either"];
+  var Data_Identity = PS["Data.Identity"];
+  var Data_Newtype = PS["Data.Newtype"];
+  var Prelude = PS["Prelude"];                                                           
+  var runExcept = function ($0) {
+      return Data_Newtype.unwrap(Data_Identity.newtypeIdentity)(Control_Monad_Except_Trans.runExceptT($0));
+  };
+  var mapExcept = function (f) {
+      return Control_Monad_Except_Trans.mapExceptT(function ($1) {
+          return Data_Identity.Identity(f(Data_Newtype.unwrap(Data_Identity.newtypeIdentity)($1)));
+      });
+  };
+  exports["runExcept"] = runExcept;
+  exports["mapExcept"] = mapExcept;
+})(PS["Control.Monad.Except"] = PS["Control.Monad.Except"] || {});
 (function(exports) {
     "use strict";
 
-  exports.boolConj = function (b1) {
-    return function (b2) {
-      return b1 && b2;
+  exports.map_ = function (f) {
+    return function (a) {
+      return function () {
+        return f(a());
+      };
     };
   };
 
-  exports.boolDisj = function (b1) {
-    return function (b2) {
-      return b1 || b2;
+  exports.pure_ = function (a) {
+    return function () {
+      return a;
     };
   };
 
-  exports.boolNot = function (b) {
-    return !b;
-  };
-})(PS["Data.HeytingAlgebra"] = PS["Data.HeytingAlgebra"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Data.HeytingAlgebra"];
-  var Data_Unit = PS["Data.Unit"];        
-  var HeytingAlgebra = function (conj, disj, ff, implies, not, tt) {
-      this.conj = conj;
-      this.disj = disj;
-      this.ff = ff;
-      this.implies = implies;
-      this.not = not;
-      this.tt = tt;
-  };
-  var tt = function (dict) {
-      return dict.tt;
-  };
-  var not = function (dict) {
-      return dict.not;
-  };
-  var implies = function (dict) {
-      return dict.implies;
-  };                 
-  var ff = function (dict) {
-      return dict.ff;
-  };
-  var disj = function (dict) {
-      return dict.disj;
-  };
-  var heytingAlgebraBoolean = new HeytingAlgebra($foreign.boolConj, $foreign.boolDisj, false, function (a) {
-      return function (b) {
-          return disj(heytingAlgebraBoolean)(not(heytingAlgebraBoolean)(a))(b);
+  exports.bind_ = function (a) {
+    return function (f) {
+      return function () {
+        return f(a())();
       };
-  }, $foreign.boolNot, true);
-  var conj = function (dict) {
-      return dict.conj;
+    };
   };
-  exports["HeytingAlgebra"] = HeytingAlgebra;
-  exports["tt"] = tt;
-  exports["ff"] = ff;
-  exports["implies"] = implies;
-  exports["conj"] = conj;
-  exports["disj"] = disj;
-  exports["not"] = not;
-  exports["heytingAlgebraBoolean"] = heytingAlgebraBoolean;
-})(PS["Data.HeytingAlgebra"] = PS["Data.HeytingAlgebra"] || {});
+})(PS["Control.Monad.ST.Internal"] = PS["Control.Monad.ST.Internal"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var otherwise = true;
-  exports["otherwise"] = otherwise;
-})(PS["Data.Boolean"] = PS["Data.Boolean"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Data_Boolean = PS["Data.Boolean"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_EuclideanRing = PS["Data.EuclideanRing"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Ord = PS["Data.Ord"];
-  var Data_Ordering = PS["Data.Ordering"];
-  var Data_Semigroup = PS["Data.Semigroup"];
+  var $foreign = PS["Control.Monad.ST.Internal"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Monad = PS["Control.Monad"];
+  var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
+  var Data_Functor = PS["Data.Functor"];
   var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];        
-  var Monoid = function (Semigroup0, mempty) {
-      this.Semigroup0 = Semigroup0;
-      this.mempty = mempty;
-  };                 
-  var monoidString = new Monoid(function () {
-      return Data_Semigroup.semigroupString;
-  }, "");  
-  var mempty = function (dict) {
-      return dict.mempty;
-  };
-  exports["Monoid"] = Monoid;
-  exports["mempty"] = mempty;
-  exports["monoidString"] = monoidString;
-})(PS["Data.Monoid"] = PS["Data.Monoid"] || {});
+  var Partial_Unsafe = PS["Partial.Unsafe"];
+  var Prelude = PS["Prelude"];
+  var functorST = new Data_Functor.Functor($foreign.map_);
+  var monadST = new Control_Monad.Monad(function () {
+      return applicativeST;
+  }, function () {
+      return bindST;
+  });
+  var bindST = new Control_Bind.Bind(function () {
+      return applyST;
+  }, $foreign.bind_);
+  var applyST = new Control_Apply.Apply(function () {
+      return functorST;
+  }, Control_Monad.ap(monadST));
+  var applicativeST = new Control_Applicative.Applicative(function () {
+      return applyST;
+  }, $foreign.pure_);
+  exports["functorST"] = functorST;
+  exports["applyST"] = applyST;
+  exports["applicativeST"] = applicativeST;
+  exports["bindST"] = bindST;
+  exports["monadST"] = monadST;
+})(PS["Control.Monad.ST.Internal"] = PS["Control.Monad.ST.Internal"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Alt = PS["Control.Alt"];
   var Control_Alternative = PS["Control.Alternative"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
-  var Control_Category = PS["Control.Category"];
+  var Control_Comonad = PS["Control.Comonad"];
   var Control_Extend = PS["Control.Extend"];
+  var Control_Lazy = PS["Control.Lazy"];
   var Control_Monad = PS["Control.Monad"];
+  var Control_MonadPlus = PS["Control.MonadPlus"];
   var Control_MonadZero = PS["Control.MonadZero"];
   var Control_Plus = PS["Control.Plus"];
-  var Data_Bounded = PS["Data.Bounded"];
   var Data_Eq = PS["Data.Eq"];
-  var Data_Function = PS["Data.Function"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
   var Data_Monoid = PS["Data.Monoid"];
+  var Data_Newtype = PS["Data.Newtype"];
   var Data_Ord = PS["Data.Ord"];
-  var Data_Ordering = PS["Data.Ordering"];
   var Data_Semigroup = PS["Data.Semigroup"];
   var Data_Show = PS["Data.Show"];
-  var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];        
-  var Nothing = (function () {
-      function Nothing() {
-
-      };
-      Nothing.value = new Nothing();
-      return Nothing;
-  })();
-  var Just = (function () {
-      function Just(value0) {
-          this.value0 = value0;
-      };
-      Just.create = function (value0) {
-          return new Just(value0);
-      };
-      return Just;
-  })();
-  var maybe = function (v) {
-      return function (v1) {
-          return function (v2) {
-              if (v2 instanceof Nothing) {
-                  return v;
-              };
-              if (v2 instanceof Just) {
-                  return v1(v2.value0);
+  var Data_Traversable = PS["Data.Traversable"];
+  var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
+  var Prelude = PS["Prelude"];
+  var Unsafe_Coerce = PS["Unsafe.Coerce"];                 
+  var App = function (x) {
+      return x;
+  };
+  var semigroupApp = function (dictApply) {
+      return function (dictSemigroup) {
+          return new Data_Semigroup.Semigroup(function (v) {
+              return function (v1) {
+                  return Control_Apply.lift2(dictApply)(Data_Semigroup.append(dictSemigroup))(v)(v1);
               };
-              throw new Error("Failed pattern match at Data.Maybe line 219, column 1 - line 219, column 51: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
-          };
-      };
-  };                                                      
-  var functorMaybe = new Data_Functor.Functor(function (v) {
-      return function (v1) {
-          if (v1 instanceof Just) {
-              return new Just(v(v1.value0));
-          };
-          return Nothing.value;
+          });
       };
-  });
-  var fromMaybe = function (a) {
-      return maybe(a)(Control_Category.id(Control_Category.categoryFn));
   };
-  exports["Nothing"] = Nothing;
-  exports["Just"] = Just;
-  exports["maybe"] = maybe;
-  exports["fromMaybe"] = fromMaybe;
-  exports["functorMaybe"] = functorMaybe;
-})(PS["Data.Maybe"] = PS["Data.Maybe"] || {});
+  var newtypeApp = new Data_Newtype.Newtype(function (n) {
+      return n;
+  }, App);
+  var applicativeApp = function (dictApplicative) {
+      return dictApplicative;
+  };
+  exports["App"] = App;
+  exports["newtypeApp"] = newtypeApp;
+  exports["semigroupApp"] = semigroupApp;
+  exports["applicativeApp"] = applicativeApp;
+})(PS["Data.Functor.App"] = PS["Data.Functor.App"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
+  var Control_Alt = PS["Control.Alt"];
+  var Control_Alternative = PS["Control.Alternative"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Apply = PS["Control.Apply"];
-  var Control_Bind = PS["Control.Bind"];
-  var Control_Comonad = PS["Control.Comonad"];
-  var Control_Extend = PS["Control.Extend"];
-  var Control_Monad = PS["Control.Monad"];
-  var Data_Bounded = PS["Data.Bounded"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Plus = PS["Control.Plus"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
   var Data_Eq = PS["Data.Eq"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
+  var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
-  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
-  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Functor_App = PS["Data.Functor.App"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
   var Data_Newtype = PS["Data.Newtype"];
   var Data_Ord = PS["Data.Ord"];
   var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Semiring = PS["Data.Semiring"];
   var Data_Show = PS["Data.Show"];
-  var Prelude = PS["Prelude"];        
-  var Disj = function (x) {
+  var Data_Traversable = PS["Data.Traversable"];
+  var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Prelude = PS["Prelude"];                 
+  var Compose = function (x) {
       return x;
+  };          
+  var functorCompose = function (dictFunctor) {
+      return function (dictFunctor1) {
+          return new Data_Functor.Functor(function (f) {
+              return function (v) {
+                  return Compose(Data_Functor.map(dictFunctor)(Data_Functor.map(dictFunctor1)(f))(v));
+              };
+          });
+      };
   };
-  var semigroupDisj = function (dictHeytingAlgebra) {
-      return new Data_Semigroup.Semigroup(function (v) {
-          return function (v1) {
-              return Data_HeytingAlgebra.disj(dictHeytingAlgebra)(v)(v1);
-          };
-      });
+  var applyCompose = function (dictApply) {
+      return function (dictApply1) {
+          return new Control_Apply.Apply(function () {
+              return functorCompose(dictApply.Functor0())(dictApply1.Functor0());
+          }, function (v) {
+              return function (v1) {
+                  return Compose(Control_Apply.apply(dictApply)(Data_Functor.map(dictApply.Functor0())(Control_Apply.apply(dictApply1))(v))(v1));
+              };
+          });
+      };
   };
-  var newtypeDisj = new Data_Newtype.Newtype(function (n) {
-      return n;
-  }, Disj);
-  var monoidDisj = function (dictHeytingAlgebra) {
-      return new Data_Monoid.Monoid(function () {
-          return semigroupDisj(dictHeytingAlgebra);
-      }, Data_HeytingAlgebra.ff(dictHeytingAlgebra));
+  var applicativeCompose = function (dictApplicative) {
+      return function (dictApplicative1) {
+          return new Control_Applicative.Applicative(function () {
+              return applyCompose(dictApplicative.Apply0())(dictApplicative1.Apply0());
+          }, function ($104) {
+              return Compose(Control_Applicative.pure(dictApplicative)(Control_Applicative.pure(dictApplicative1)($104)));
+          });
+      };
+  };
+  exports["Compose"] = Compose;
+  exports["functorCompose"] = functorCompose;
+  exports["applyCompose"] = applyCompose;
+  exports["applicativeCompose"] = applicativeCompose;
+})(PS["Data.Functor.Compose"] = PS["Data.Functor.Compose"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.new = function (val) {
+    return function () {
+      return { value: val };
+    };
+  };
+
+  exports.read = function (ref) {
+    return function () {
+      return ref.value;
+    };
+  };
+
+  exports.write = function (val) {
+    return function (ref) {
+      return function () {
+        ref.value = val;
+        return {};
+      };
+    };
   };
-  exports["Disj"] = Disj;
-  exports["newtypeDisj"] = newtypeDisj;
-  exports["semigroupDisj"] = semigroupDisj;
-  exports["monoidDisj"] = monoidDisj;
-})(PS["Data.Monoid.Disj"] = PS["Data.Monoid.Disj"] || {});
+})(PS["Effect.Ref"] = PS["Effect.Ref"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Effect.Ref"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Effect = PS["Effect"];
+  var Prelude = PS["Prelude"];
+  exports["new"] = $foreign["new"];
+  exports["read"] = $foreign.read;
+  exports["write"] = $foreign.write;
+})(PS["Effect.Ref"] = PS["Effect.Ref"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.Foldable"];
   var Control_Alt = PS["Control.Alt"];
+  var Control_Alternative = PS["Control.Alternative"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
-  var Control_Category = PS["Control.Category"];
+  var Control_Monad_Cont_Trans = PS["Control.Monad.Cont.Trans"];
+  var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
+  var Control_Monad_Maybe_Trans = PS["Control.Monad.Maybe.Trans"];
+  var Control_Monad_Reader_Trans = PS["Control.Monad.Reader.Trans"];
+  var Control_Monad_Writer_Trans = PS["Control.Monad.Writer.Trans"];
   var Control_Plus = PS["Control.Plus"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Eq = PS["Data.Eq"];
+  var Data_Either = PS["Data.Either"];
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Functor_Compose = PS["Data.Functor.Compose"];
   var Data_Maybe = PS["Data.Maybe"];
-  var Data_Maybe_First = PS["Data.Maybe.First"];
-  var Data_Maybe_Last = PS["Data.Maybe.Last"];
-  var Data_Monoid = PS["Data.Monoid"];
-  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
-  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
-  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
-  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
-  var Data_Monoid_Endo = PS["Data.Monoid.Endo"];
-  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
   var Data_Newtype = PS["Data.Newtype"];
-  var Data_Ord = PS["Data.Ord"];
-  var Data_Ordering = PS["Data.Ordering"];
-  var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Semiring = PS["Data.Semiring"];
   var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];        
-  var Foldable = function (foldMap, foldl, foldr) {
-      this.foldMap = foldMap;
-      this.foldl = foldl;
-      this.foldr = foldr;
+  var Effect_Class = PS["Effect.Class"];
+  var Effect_Ref = PS["Effect.Ref"];
+  var Prelude = PS["Prelude"];                 
+  var ParCont = function (x) {
+      return x;
   };
-  var foldr = function (dict) {
-      return dict.foldr;
+  var Parallel = function (Applicative1, Monad0, parallel, sequential) {
+      this.Applicative1 = Applicative1;
+      this.Monad0 = Monad0;
+      this.parallel = parallel;
+      this.sequential = sequential;
   };
-  var traverse_ = function (dictApplicative) {
-      return function (dictFoldable) {
-          return function (f) {
-              return foldr(dictFoldable)(function ($184) {
-                  return Control_Apply.applySecond(dictApplicative.Apply0())(f($184));
-              })(Control_Applicative.pure(dictApplicative)(Data_Unit.unit));
-          };
-      };
+  var sequential = function (dict) {
+      return dict.sequential;
   };
-  var for_ = function (dictApplicative) {
-      return function (dictFoldable) {
-          return Data_Function.flip(traverse_(dictApplicative)(dictFoldable));
-      };
+  var parallel = function (dict) {
+      return dict.parallel;
   };
-  var foldl = function (dict) {
-      return dict.foldl;
+  var monadParExceptT = function (dictParallel) {
+      return new Parallel(function () {
+          return Data_Functor_Compose.applicativeCompose(dictParallel.Applicative1())(Data_Either.applicativeEither);
+      }, function () {
+          return Control_Monad_Except_Trans.monadExceptT(dictParallel.Monad0());
+      }, function (v) {
+          return parallel(dictParallel)(v);
+      }, function (v) {
+          return sequential(dictParallel)(v);
+      });
   };
-  var intercalate = function (dictFoldable) {
-      return function (dictMonoid) {
-          return function (sep) {
-              return function (xs) {
-                  var go = function (v) {
-                      return function (x) {
-                          if (v.init) {
-                              return {
-                                  init: false,
-                                  acc: x
-                              };
-                          };
-                          return {
-                              init: false,
-                              acc: Data_Semigroup.append(dictMonoid.Semigroup0())(v.acc)(Data_Semigroup.append(dictMonoid.Semigroup0())(sep)(x))
-                          };
-                      };
-                  };
-                  return (foldl(dictFoldable)(go)({
-                      init: true,
-                      acc: Data_Monoid.mempty(dictMonoid)
-                  })(xs)).acc;
-              };
-          };
-      };
-  }; 
-  var foldableMaybe = new Foldable(function (dictMonoid) {
-      return function (f) {
-          return function (v) {
-              if (v instanceof Data_Maybe.Nothing) {
-                  return Data_Monoid.mempty(dictMonoid);
-              };
-              if (v instanceof Data_Maybe.Just) {
-                  return f(v.value0);
-              };
-              throw new Error("Failed pattern match at Data.Foldable line 129, column 1 - line 129, column 41: " + [ f.constructor.name, v.constructor.name ]);
-          };
-      };
-  }, function (v) {
-      return function (z) {
-          return function (v1) {
-              if (v1 instanceof Data_Maybe.Nothing) {
-                  return z;
-              };
-              if (v1 instanceof Data_Maybe.Just) {
-                  return v(z)(v1.value0);
-              };
-              throw new Error("Failed pattern match at Data.Foldable line 129, column 1 - line 129, column 41: " + [ v.constructor.name, z.constructor.name, v1.constructor.name ]);
+  var monadParParCont = function (dictMonadEffect) {
+      return new Parallel(function () {
+          return applicativeParCont(dictMonadEffect);
+      }, function () {
+          return Control_Monad_Cont_Trans.monadContT(dictMonadEffect.Monad0());
+      }, ParCont, function (v) {
+          return v;
+      });
+  };
+  var functorParCont = function (dictMonadEffect) {
+      return new Data_Functor.Functor(function (f) {
+          return function ($54) {
+              return parallel(monadParParCont(dictMonadEffect))(Data_Functor.map(Control_Monad_Cont_Trans.functorContT((((dictMonadEffect.Monad0()).Bind1()).Apply0()).Functor0()))(f)(sequential(monadParParCont(dictMonadEffect))($54)));
           };
-      };
-  }, function (v) {
-      return function (z) {
+      });
+  };
+  var applyParCont = function (dictMonadEffect) {
+      return new Control_Apply.Apply(function () {
+          return functorParCont(dictMonadEffect);
+      }, function (v) {
           return function (v1) {
-              if (v1 instanceof Data_Maybe.Nothing) {
-                  return z;
-              };
-              if (v1 instanceof Data_Maybe.Just) {
-                  return v(v1.value0)(z);
-              };
-              throw new Error("Failed pattern match at Data.Foldable line 129, column 1 - line 129, column 41: " + [ v.constructor.name, z.constructor.name, v1.constructor.name ]);
-          };
-      };
-  });
-  var foldMapDefaultR = function (dictFoldable) {
-      return function (dictMonoid) {
-          return function (f) {
-              return foldr(dictFoldable)(function (x) {
-                  return function (acc) {
-                      return Data_Semigroup.append(dictMonoid.Semigroup0())(f(x))(acc);
-                  };
-              })(Data_Monoid.mempty(dictMonoid));
+              return ParCont(function (k) {
+                  return Control_Bind.bind((dictMonadEffect.Monad0()).Bind1())(Effect_Class.liftEffect(dictMonadEffect)(Effect_Ref["new"](Data_Maybe.Nothing.value)))(function (v2) {
+                      return Control_Bind.bind((dictMonadEffect.Monad0()).Bind1())(Effect_Class.liftEffect(dictMonadEffect)(Effect_Ref["new"](Data_Maybe.Nothing.value)))(function (v3) {
+                          return Control_Bind.discard(Control_Bind.discardUnit)((dictMonadEffect.Monad0()).Bind1())(Control_Monad_Cont_Trans.runContT(v)(function (a) {
+                              return Control_Bind.bind((dictMonadEffect.Monad0()).Bind1())(Effect_Class.liftEffect(dictMonadEffect)(Effect_Ref.read(v3)))(function (v4) {
+                                  if (v4 instanceof Data_Maybe.Nothing) {
+                                      return Effect_Class.liftEffect(dictMonadEffect)(Effect_Ref.write(new Data_Maybe.Just(a))(v2));
+                                  };
+                                  if (v4 instanceof Data_Maybe.Just) {
+                                      return k(a(v4.value0));
+                                  };
+                                  throw new Error("Failed pattern match at Control.Parallel.Class line 71, column 7 - line 73, column 26: " + [ v4.constructor.name ]);
+                              });
+                          }))(function () {
+                              return Control_Monad_Cont_Trans.runContT(v1)(function (b) {
+                                  return Control_Bind.bind((dictMonadEffect.Monad0()).Bind1())(Effect_Class.liftEffect(dictMonadEffect)(Effect_Ref.read(v2)))(function (v4) {
+                                      if (v4 instanceof Data_Maybe.Nothing) {
+                                          return Effect_Class.liftEffect(dictMonadEffect)(Effect_Ref.write(new Data_Maybe.Just(b))(v3));
+                                      };
+                                      if (v4 instanceof Data_Maybe.Just) {
+                                          return k(v4.value0(b));
+                                      };
+                                      throw new Error("Failed pattern match at Control.Parallel.Class line 77, column 7 - line 79, column 26: " + [ v4.constructor.name ]);
+                                  });
+                              });
+                          });
+                      });
+                  });
+              });
           };
-      };
-  };
-  var foldableArray = new Foldable(function (dictMonoid) {
-      return foldMapDefaultR(foldableArray)(dictMonoid);
-  }, $foreign.foldlArray, $foreign.foldrArray);
-  var foldMap = function (dict) {
-      return dict.foldMap;
-  };
-  var fold = function (dictFoldable) {
-      return function (dictMonoid) {
-          return foldMap(dictFoldable)(dictMonoid)(Control_Category.id(Control_Category.categoryFn));
-      };
+      });
   };
-  var any = function (dictFoldable) {
-      return function (dictHeytingAlgebra) {
-          return Data_Newtype.alaF(Data_Functor.functorFn)(Data_Functor.functorFn)(Data_Monoid_Disj.newtypeDisj)(Data_Monoid_Disj.newtypeDisj)(Data_Monoid_Disj.Disj)(foldMap(dictFoldable)(Data_Monoid_Disj.monoidDisj(dictHeytingAlgebra)));
-      };
+  var applicativeParCont = function (dictMonadEffect) {
+      return new Control_Applicative.Applicative(function () {
+          return applyParCont(dictMonadEffect);
+      }, function ($55) {
+          return parallel(monadParParCont(dictMonadEffect))(Control_Applicative.pure(Control_Monad_Cont_Trans.applicativeContT((dictMonadEffect.Monad0()).Applicative0()))($55));
+      });
   };
-  var elem = function (dictFoldable) {
-      return function (dictEq) {
-          return function ($187) {
-              return any(dictFoldable)(Data_HeytingAlgebra.heytingAlgebraBoolean)(Data_Eq.eq(dictEq)($187));
+  exports["parallel"] = parallel;
+  exports["sequential"] = sequential;
+  exports["Parallel"] = Parallel;
+  exports["ParCont"] = ParCont;
+  exports["monadParExceptT"] = monadParExceptT;
+  exports["functorParCont"] = functorParCont;
+  exports["applyParCont"] = applyParCont;
+  exports["applicativeParCont"] = applicativeParCont;
+  exports["monadParParCont"] = monadParParCont;
+})(PS["Control.Parallel.Class"] = PS["Control.Parallel.Class"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Alternative = PS["Control.Alternative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Parallel_Class = PS["Control.Parallel.Class"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_Traversable = PS["Data.Traversable"];
+  var Prelude = PS["Prelude"];
+  var parTraverse = function (dictParallel) {
+      return function (dictTraversable) {
+          return function (f) {
+              return function ($19) {
+                  return Control_Parallel_Class.sequential(dictParallel)(Data_Traversable.traverse(dictTraversable)(dictParallel.Applicative1())(function ($20) {
+                      return Control_Parallel_Class.parallel(dictParallel)(f($20));
+                  })($19));
+              };
           };
       };
   };
-  exports["Foldable"] = Foldable;
-  exports["foldr"] = foldr;
-  exports["foldl"] = foldl;
-  exports["foldMap"] = foldMap;
-  exports["foldMapDefaultR"] = foldMapDefaultR;
-  exports["fold"] = fold;
-  exports["traverse_"] = traverse_;
-  exports["for_"] = for_;
-  exports["intercalate"] = intercalate;
-  exports["any"] = any;
-  exports["elem"] = elem;
-  exports["foldableArray"] = foldableArray;
-  exports["foldableMaybe"] = foldableMaybe;
-})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
+  exports["parTraverse"] = parTraverse;
+})(PS["Control.Parallel"] = PS["Control.Parallel"] || {});
 (function(exports) {
     "use strict";
 
-  // jshint maxparams: 3
-
-  exports.traverseArrayImpl = function () {
-    function Cont(fn) {
-      this.fn = fn;
-    }
+  //------------------------------------------------------------------------------
+  // Array creation --------------------------------------------------------------
+  //------------------------------------------------------------------------------
 
-    var emptyList = {};
+  exports.range = function (start) {
+    return function (end) {
+      var step = start > end ? -1 : 1;
+      var result = new Array(step * (end - start) + 1);
+      var i = start, n = 0;
+      while (i !== end) {
+        result[n++] = i;
+        i += step;
+      }
+      result[n] = i;
+      return result;
+    };
+  };                                                                                             
 
-    var ConsCell = function (head, tail) {
+  exports.fromFoldableImpl = (function () {
+    function Cons(head, tail) {
       this.head = head;
       this.tail = tail;
-    };
+    }
+    var emptyList = {};
 
-    function consList(x) {
-      return function (xs) {
-        return new ConsCell(x, xs);
+    function curryCons(head) {
+      return function (tail) {
+        return new Cons(head, tail);
       };
     }
 
     function listToArray(list) {
-      var arr = [];
+      var result = [];
+      var count = 0;
       var xs = list;
       while (xs !== emptyList) {
-        arr.push(xs.head);
+        result[count++] = xs.head;
         xs = xs.tail;
       }
-      return arr;
+      return result;
     }
 
-    return function (apply) {
-      return function (map) {
-        return function (pure) {
-          return function (f) {
-            var buildFrom = function (x, ys) {
-              return apply(map(consList)(f(x)))(ys);
-            };
+    return function (foldr) {
+      return function (xs) {
+        return listToArray(foldr(curryCons)(emptyList)(xs));
+      };
+    };
+  })();
 
-            var go = function (acc, currentLen, xs) {
-              if (currentLen === 0) {
-                return acc;
-              } else {
-                var last = xs[currentLen - 1];
-                return new Cont(function () {
-                  return go(buildFrom(last, acc), currentLen - 1, xs);
-                });
-              }
-            };
+  //------------------------------------------------------------------------------
+  // Array size ------------------------------------------------------------------
+  //------------------------------------------------------------------------------
 
-            return function (array) {
-              var result = go(pure(emptyList), array.length, array);
-              while (result instanceof Cont) {
-                result = result.fn();
-              }
+  exports.length = function (xs) {
+    return xs.length;
+  };
 
-              return map(listToArray)(result);
-            };
-          };
-        };
+  //------------------------------------------------------------------------------
+  // Zipping ---------------------------------------------------------------------
+  //------------------------------------------------------------------------------
+
+  exports.zipWith = function (f) {
+    return function (xs) {
+      return function (ys) {
+        var l = xs.length < ys.length ? xs.length : ys.length;
+        var result = new Array(l);
+        for (var i = 0; i < l; i++) {
+          result[i] = f(xs[i])(ys[i]);
+        }
+        return result;
       };
     };
-  }();
-})(PS["Data.Traversable"] = PS["Data.Traversable"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Data.Traversable"];
-  var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
-  var Control_Category = PS["Control.Category"];
-  var Data_Foldable = PS["Data.Foldable"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_Maybe_First = PS["Data.Maybe.First"];
-  var Data_Maybe_Last = PS["Data.Maybe.Last"];
-  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
-  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
-  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
-  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
-  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
-  var Data_Traversable_Accum = PS["Data.Traversable.Accum"];
-  var Data_Traversable_Accum_Internal = PS["Data.Traversable.Accum.Internal"];
-  var Prelude = PS["Prelude"];        
-  var Traversable = function (Foldable1, Functor0, sequence, traverse) {
-      this.Foldable1 = Foldable1;
-      this.Functor0 = Functor0;
-      this.sequence = sequence;
-      this.traverse = traverse;
-  };
-  var traverse = function (dict) {
-      return dict.traverse;
-  }; 
-  var sequenceDefault = function (dictTraversable) {
-      return function (dictApplicative) {
-          return traverse(dictTraversable)(dictApplicative)(Control_Category.id(Control_Category.categoryFn));
-      };
-  };
-  var traversableArray = new Traversable(function () {
-      return Data_Foldable.foldableArray;
-  }, function () {
-      return Data_Functor.functorArray;
-  }, function (dictApplicative) {
-      return sequenceDefault(traversableArray)(dictApplicative);
-  }, function (dictApplicative) {
-      return $foreign.traverseArrayImpl(Control_Apply.apply(dictApplicative.Apply0()))(Data_Functor.map((dictApplicative.Apply0()).Functor0()))(Control_Applicative.pure(dictApplicative));
-  });
-  var sequence = function (dict) {
-      return dict.sequence;
   };
-  exports["Traversable"] = Traversable;
-  exports["traverse"] = traverse;
-  exports["sequence"] = sequence;
-  exports["sequenceDefault"] = sequenceDefault;
-  exports["traversableArray"] = traversableArray;
-})(PS["Data.Traversable"] = PS["Data.Traversable"] || {});
+})(PS["Data.Array"] = PS["Data.Array"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Control_Alt = PS["Control.Alt"];
-  var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
-  var Control_Bind = PS["Control.Bind"];
-  var Control_Extend = PS["Control.Extend"];
-  var Control_Monad = PS["Control.Monad"];
-  var Data_Bifoldable = PS["Data.Bifoldable"];
-  var Data_Bifunctor = PS["Data.Bifunctor"];
-  var Data_Bitraversable = PS["Data.Bitraversable"];
-  var Data_Bounded = PS["Data.Bounded"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_Foldable = PS["Data.Foldable"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_Monoid = PS["Data.Monoid"];
-  var Data_Ord = PS["Data.Ord"];
-  var Data_Ordering = PS["Data.Ordering"];
-  var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Semiring = PS["Data.Semiring"];
-  var Data_Show = PS["Data.Show"];
-  var Data_Traversable = PS["Data.Traversable"];
-  var Prelude = PS["Prelude"];        
-  var Left = (function () {
-      function Left(value0) {
-          this.value0 = value0;
-      };
-      Left.create = function (value0) {
-          return new Left(value0);
-      };
-      return Left;
-  })();
-  var Right = (function () {
-      function Right(value0) {
-          this.value0 = value0;
-      };
-      Right.create = function (value0) {
-          return new Right(value0);
-      };
-      return Right;
-  })();
-  var functorEither = new Data_Functor.Functor(function (v) {
-      return function (v1) {
-          if (v1 instanceof Left) {
-              return new Left(v1.value0);
-          };
-          if (v1 instanceof Right) {
-              return new Right(v(v1.value0));
-          };
-          throw new Error("Failed pattern match at Data.Either line 36, column 1 - line 36, column 45: " + [ v.constructor.name, v1.constructor.name ]);
-      };
-  });                                                                                                     
-  var fromRight = function (dictPartial) {
-      return function (v) {
-          var __unused = function (dictPartial1) {
-              return function ($dollar62) {
-                  return $dollar62;
-              };
-          };
-          return __unused(dictPartial)((function () {
-              if (v instanceof Right) {
-                  return v.value0;
-              };
-              throw new Error("Failed pattern match at Data.Either line 252, column 1 - line 252, column 52: " + [ v.constructor.name ]);
-          })());
-      };
-  };
-  var either = function (v) {
-      return function (v1) {
-          return function (v2) {
-              if (v2 instanceof Left) {
-                  return v(v2.value0);
-              };
-              if (v2 instanceof Right) {
-                  return v1(v2.value0);
-              };
-              throw new Error("Failed pattern match at Data.Either line 229, column 1 - line 229, column 64: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
+    "use strict";
+
+  exports.unfoldrArrayImpl = function (isNothing) {
+    return function (fromJust) {
+      return function (fst) {
+        return function (snd) {
+          return function (f) {
+            return function (b) {
+              var result = [];
+              var value = b;
+              while (true) { // eslint-disable-line no-constant-condition
+                var maybe = f(value);
+                if (isNothing(maybe)) return result;
+                var tuple = fromJust(maybe);
+                result.push(fst(tuple));
+                value = snd(tuple);
+              }
+            };
           };
+        };
       };
+    };
   };
-  var bifunctorEither = new Data_Bifunctor.Bifunctor(function (v) {
-      return function (v1) {
-          return function (v2) {
-              if (v2 instanceof Left) {
-                  return new Left(v(v2.value0));
-              };
-              if (v2 instanceof Right) {
-                  return new Right(v1(v2.value0));
-              };
-              throw new Error("Failed pattern match at Data.Either line 43, column 1 - line 43, column 45: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
-          };
-      };
-  });
-  var applyEither = new Control_Apply.Apply(function () {
-      return functorEither;
-  }, function (v) {
-      return function (v1) {
-          if (v instanceof Left) {
-              return new Left(v.value0);
-          };
-          if (v instanceof Right) {
-              return Data_Functor.map(functorEither)(v.value0)(v1);
+})(PS["Data.Unfoldable"] = PS["Data.Unfoldable"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.unfoldr1ArrayImpl = function (isNothing) {
+    return function (fromJust) {
+      return function (fst) {
+        return function (snd) {
+          return function (f) {
+            return function (b) {
+              var result = [];
+              var value = b;
+              while (true) { // eslint-disable-line no-constant-condition
+                var tuple = f(value);
+                result.push(fst(tuple));
+                var maybe = snd(tuple);
+                if (isNothing(maybe)) return result;
+                value = fromJust(maybe);
+              }
+            };
           };
-          throw new Error("Failed pattern match at Data.Either line 79, column 1 - line 79, column 41: " + [ v.constructor.name, v1.constructor.name ]);
+        };
       };
-  });
-  var applicativeEither = new Control_Applicative.Applicative(function () {
-      return applyEither;
-  }, Right.create);
-  exports["Left"] = Left;
-  exports["Right"] = Right;
-  exports["either"] = either;
-  exports["fromRight"] = fromRight;
-  exports["functorEither"] = functorEither;
-  exports["bifunctorEither"] = bifunctorEither;
-  exports["applyEither"] = applyEither;
-  exports["applicativeEither"] = applicativeEither;
-})(PS["Data.Either"] = PS["Data.Either"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Control_Applicative = PS["Control.Applicative"];
-  var Control_Bind = PS["Control.Bind"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Either = PS["Data.Either"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];        
-  var MonadThrow = function (Monad0, throwError) {
-      this.Monad0 = Monad0;
-      this.throwError = throwError;
-  };
-  var throwError = function (dict) {
-      return dict.throwError;
+    };
   };
-  exports["throwError"] = throwError;
-  exports["MonadThrow"] = MonadThrow;
-})(PS["Control.Monad.Error.Class"] = PS["Control.Monad.Error.Class"] || {});
+})(PS["Data.Unfoldable1"] = PS["Data.Unfoldable1"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
-  var Control_Biapplicative = PS["Control.Biapplicative"];
-  var Control_Biapply = PS["Control.Biapply"];
-  var Control_Bind = PS["Control.Bind"];
-  var Control_Comonad = PS["Control.Comonad"];
-  var Control_Extend = PS["Control.Extend"];
-  var Control_Lazy = PS["Control.Lazy"];
-  var Control_Monad = PS["Control.Monad"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Bifoldable = PS["Data.Bifoldable"];
-  var Data_Bifunctor = PS["Data.Bifunctor"];
-  var Data_Bitraversable = PS["Data.Bitraversable"];
-  var Data_BooleanAlgebra = PS["Data.BooleanAlgebra"];
-  var Data_Bounded = PS["Data.Bounded"];
-  var Data_CommutativeRing = PS["Data.CommutativeRing"];
-  var Data_Distributive = PS["Data.Distributive"];
+  var $foreign = PS["Data.Unfoldable1"];
+  var Data_Boolean = PS["Data.Boolean"];
   var Data_Eq = PS["Data.Eq"];
-  var Data_Foldable = PS["Data.Foldable"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ring = PS["Data.Ring"];
+  var Data_Semigroup_Traversable = PS["Data.Semigroup.Traversable"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Partial_Unsafe = PS["Partial.Unsafe"];
+  var Prelude = PS["Prelude"];                 
+  var Unfoldable1 = function (unfoldr1) {
+      this.unfoldr1 = unfoldr1;
+  };
+  var unfoldr1 = function (dict) {
+      return dict.unfoldr1;
+  };
+  var unfoldable1Array = new Unfoldable1($foreign.unfoldr1ArrayImpl(Data_Maybe.isNothing)(Data_Maybe.fromJust())(Data_Tuple.fst)(Data_Tuple.snd));
+  exports["Unfoldable1"] = Unfoldable1;
+  exports["unfoldr1"] = unfoldr1;
+  exports["unfoldable1Array"] = unfoldable1Array;
+})(PS["Data.Unfoldable1"] = PS["Data.Unfoldable1"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Unfoldable"];
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
-  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
   var Data_Maybe = PS["Data.Maybe"];
-  var Data_Maybe_First = PS["Data.Maybe.First"];
-  var Data_Monoid = PS["Data.Monoid"];
-  var Data_Newtype = PS["Data.Newtype"];
   var Data_Ord = PS["Data.Ord"];
-  var Data_Ordering = PS["Data.Ordering"];
   var Data_Ring = PS["Data.Ring"];
-  var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Semiring = PS["Data.Semiring"];
-  var Data_Show = PS["Data.Show"];
   var Data_Traversable = PS["Data.Traversable"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Data_Unfoldable1 = PS["Data.Unfoldable1"];
   var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];
-  var Type_Equality = PS["Type.Equality"];        
-  var Tuple = (function () {
-      function Tuple(value0, value1) {
-          this.value0 = value0;
-          this.value1 = value1;
-      };
-      Tuple.create = function (value0) {
-          return function (value1) {
-              return new Tuple(value0, value1);
-          };
-      };
-      return Tuple;
-  })();
-  exports["Tuple"] = Tuple;
-})(PS["Data.Tuple"] = PS["Data.Tuple"] || {});
+  var Partial_Unsafe = PS["Partial.Unsafe"];
+  var Prelude = PS["Prelude"];                 
+  var Unfoldable = function (Unfoldable10, unfoldr) {
+      this.Unfoldable10 = Unfoldable10;
+      this.unfoldr = unfoldr;
+  };
+  var unfoldr = function (dict) {
+      return dict.unfoldr;
+  };
+  var unfoldableArray = new Unfoldable(function () {
+      return Data_Unfoldable1.unfoldable1Array;
+  }, $foreign.unfoldrArrayImpl(Data_Maybe.isNothing)(Data_Maybe.fromJust())(Data_Tuple.fst)(Data_Tuple.snd));
+  exports["Unfoldable"] = Unfoldable;
+  exports["unfoldr"] = unfoldr;
+  exports["unfoldableArray"] = unfoldableArray;
+})(PS["Data.Unfoldable"] = PS["Data.Unfoldable"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
+  var $foreign = PS["Data.Array"];
   var Control_Alt = PS["Control.Alt"];
   var Control_Alternative = PS["Control.Alternative"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
   var Control_Category = PS["Control.Category"];
-  var Control_Monad = PS["Control.Monad"];
-  var Control_Monad_Cont_Class = PS["Control.Monad.Cont.Class"];
-  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
-  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
-  var Control_Monad_Reader_Class = PS["Control.Monad.Reader.Class"];
+  var Control_Lazy = PS["Control.Lazy"];
   var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
-  var Control_Monad_State_Class = PS["Control.Monad.State.Class"];
-  var Control_Monad_Trans_Class = PS["Control.Monad.Trans.Class"];
-  var Control_Monad_Writer_Class = PS["Control.Monad.Writer.Class"];
-  var Control_MonadPlus = PS["Control.MonadPlus"];
-  var Control_MonadZero = PS["Control.MonadZero"];
-  var Control_Plus = PS["Control.Plus"];
+  var Control_Monad_ST = PS["Control.Monad.ST"];
+  var Control_Monad_ST_Internal = PS["Control.Monad.ST.Internal"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Either = PS["Data.Either"];
+  var Data_Array_NonEmpty_Internal = PS["Data.Array.NonEmpty.Internal"];
+  var Data_Array_ST = PS["Data.Array.ST"];
+  var Data_Array_ST_Iterator = PS["Data.Array.ST.Iterator"];
+  var Data_Boolean = PS["Data.Boolean"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Foldable = PS["Data.Foldable"];
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_Monoid = PS["Data.Monoid"];
-  var Data_Newtype = PS["Data.Newtype"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ordering = PS["Data.Ordering"];
+  var Data_Ring = PS["Data.Ring"];
   var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Traversable = PS["Data.Traversable"];
   var Data_Tuple = PS["Data.Tuple"];
-  var Prelude = PS["Prelude"];        
-  var ExceptT = function (x) {
-      return x;
-  };
-  var runExceptT = function (v) {
-      return v;
-  }; 
-  var mapExceptT = function (f) {
-      return function (v) {
-          return f(v);
-      };
-  };
-  var functorExceptT = function (dictFunctor) {
-      return new Data_Functor.Functor(function (f) {
-          return mapExceptT(Data_Functor.map(dictFunctor)(Data_Functor.map(Data_Either.functorEither)(f)));
-      });
-  };
-  var monadExceptT = function (dictMonad) {
-      return new Control_Monad.Monad(function () {
-          return applicativeExceptT(dictMonad);
-      }, function () {
-          return bindExceptT(dictMonad);
-      });
-  };
-  var bindExceptT = function (dictMonad) {
-      return new Control_Bind.Bind(function () {
-          return applyExceptT(dictMonad);
-      }, function (v) {
-          return function (k) {
-              return Control_Bind.bind(dictMonad.Bind1())(v)(Data_Either.either(function ($97) {
-                  return Control_Applicative.pure(dictMonad.Applicative0())(Data_Either.Left.create($97));
-              })(function (a) {
-                  var v1 = k(a);
-                  return v1;
-              }));
-          };
-      });
+  var Data_Unfoldable = PS["Data.Unfoldable"];
+  var Partial_Unsafe = PS["Partial.Unsafe"];
+  var Prelude = PS["Prelude"];
+  var Unsafe_Coerce = PS["Unsafe.Coerce"];
+  var singleton = function (a) {
+      return [ a ];
   };
-  var applyExceptT = function (dictMonad) {
-      return new Control_Apply.Apply(function () {
-          return functorExceptT(((dictMonad.Bind1()).Apply0()).Functor0());
-      }, Control_Monad.ap(monadExceptT(dictMonad)));
+  var fromFoldable = function (dictFoldable) {
+      return $foreign.fromFoldableImpl(Data_Foldable.foldr(dictFoldable));
   };
-  var applicativeExceptT = function (dictMonad) {
-      return new Control_Applicative.Applicative(function () {
-          return applyExceptT(dictMonad);
-      }, function ($98) {
-          return ExceptT(Control_Applicative.pure(dictMonad.Applicative0())(Data_Either.Right.create($98)));
+  var concatMap = Data_Function.flip(Control_Bind.bind(Control_Bind.bindArray));
+  var mapMaybe = function (f) {
+      return concatMap(function ($114) {
+          return Data_Maybe.maybe([  ])(singleton)(f($114));
       });
   };
-  var monadThrowExceptT = function (dictMonad) {
-      return new Control_Monad_Error_Class.MonadThrow(function () {
-          return monadExceptT(dictMonad);
-      }, function ($102) {
-          return ExceptT(Control_Applicative.pure(dictMonad.Applicative0())(Data_Either.Left.create($102)));
-      });
+  var catMaybes = mapMaybe(Control_Category.identity(Control_Category.categoryFn));
+  exports["fromFoldable"] = fromFoldable;
+  exports["singleton"] = singleton;
+  exports["concatMap"] = concatMap;
+  exports["mapMaybe"] = mapMaybe;
+  exports["catMaybes"] = catMaybes;
+  exports["range"] = $foreign.range;
+  exports["length"] = $foreign.length;
+  exports["zipWith"] = $foreign.zipWith;
+})(PS["Data.Array"] = PS["Data.Array"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.toCharCode = function (c) {
+    return c.charCodeAt(0);
   };
-  var altExceptT = function (dictSemigroup) {
-      return function (dictMonad) {
-          return new Control_Alt.Alt(function () {
-              return functorExceptT(((dictMonad.Bind1()).Apply0()).Functor0());
-          }, function (v) {
-              return function (v1) {
-                  return Control_Bind.bind(dictMonad.Bind1())(v)(function (v2) {
-                      if (v2 instanceof Data_Either.Right) {
-                          return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Either.Right(v2.value0));
-                      };
-                      if (v2 instanceof Data_Either.Left) {
-                          return Control_Bind.bind(dictMonad.Bind1())(v1)(function (v3) {
-                              if (v3 instanceof Data_Either.Right) {
-                                  return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Either.Right(v3.value0));
-                              };
-                              if (v3 instanceof Data_Either.Left) {
-                                  return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Either.Left(Data_Semigroup.append(dictSemigroup)(v2.value0)(v3.value0)));
-                              };
-                              throw new Error("Failed pattern match at Control.Monad.Except.Trans line 88, column 9 - line 90, column 49: " + [ v3.constructor.name ]);
-                          });
-                      };
-                      throw new Error("Failed pattern match at Control.Monad.Except.Trans line 84, column 5 - line 90, column 49: " + [ v2.constructor.name ]);
-                  });
-              };
-          });
-      };
+
+  exports.fromCharCode = function (c) {
+    return String.fromCharCode(c);
   };
-  exports["ExceptT"] = ExceptT;
-  exports["runExceptT"] = runExceptT;
-  exports["mapExceptT"] = mapExceptT;
-  exports["functorExceptT"] = functorExceptT;
-  exports["applyExceptT"] = applyExceptT;
-  exports["applicativeExceptT"] = applicativeExceptT;
-  exports["bindExceptT"] = bindExceptT;
-  exports["monadExceptT"] = monadExceptT;
-  exports["altExceptT"] = altExceptT;
-  exports["monadThrowExceptT"] = monadThrowExceptT;
-})(PS["Control.Monad.Except.Trans"] = PS["Control.Monad.Except.Trans"] || {});
+})(PS["Data.Enum"] = PS["Data.Enum"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Alt = PS["Control.Alt"];
-  var Control_Applicative = PS["Control.Applicative"];
+  var $foreign = PS["Data.Enum"];
   var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
-  var Control_Comonad = PS["Control.Comonad"];
-  var Control_Extend = PS["Control.Extend"];
-  var Control_Lazy = PS["Control.Lazy"];
-  var Control_Monad = PS["Control.Monad"];
-  var Data_BooleanAlgebra = PS["Data.BooleanAlgebra"];
+  var Control_MonadPlus = PS["Control.MonadPlus"];
+  var Control_MonadZero = PS["Control.MonadZero"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Boolean = PS["Data.Boolean"];
   var Data_Bounded = PS["Data.Bounded"];
-  var Data_CommutativeRing = PS["Data.CommutativeRing"];
+  var Data_Either = PS["Data.Either"];
   var Data_Eq = PS["Data.Eq"];
-  var Data_EuclideanRing = PS["Data.EuclideanRing"];
-  var Data_Field = PS["Data.Field"];
-  var Data_Foldable = PS["Data.Foldable"];
+  var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
   var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
-  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Maybe = PS["Data.Maybe"];
   var Data_Newtype = PS["Data.Newtype"];
   var Data_Ord = PS["Data.Ord"];
+  var Data_Ordering = PS["Data.Ordering"];
   var Data_Ring = PS["Data.Ring"];
   var Data_Semigroup = PS["Data.Semigroup"];
   var Data_Semiring = PS["Data.Semiring"];
   var Data_Show = PS["Data.Show"];
-  var Data_Traversable = PS["Data.Traversable"];
-  var Prelude = PS["Prelude"];        
-  var Identity = function (x) {
-      return x;
+  var Data_Tuple = PS["Data.Tuple"];
+  var Data_Unfoldable = PS["Data.Unfoldable"];
+  var Data_Unfoldable1 = PS["Data.Unfoldable1"];
+  var Data_Unit = PS["Data.Unit"];
+  var Partial_Unsafe = PS["Partial.Unsafe"];
+  var Prelude = PS["Prelude"];
+  var Enum = function (Ord0, pred, succ) {
+      this.Ord0 = Ord0;
+      this.pred = pred;
+      this.succ = succ;
   };
-  var newtypeIdentity = new Data_Newtype.Newtype(function (n) {
-      return n;
-  }, Identity);
-  var functorIdentity = new Data_Functor.Functor(function (f) {
-      return function (v) {
-          return f(v);
+  var BoundedEnum = function (Bounded0, Enum1, cardinality, fromEnum, toEnum) {
+      this.Bounded0 = Bounded0;
+      this.Enum1 = Enum1;
+      this.cardinality = cardinality;
+      this.fromEnum = fromEnum;
+      this.toEnum = toEnum;
+  };
+  var toEnum = function (dict) {
+      return dict.toEnum;
+  };
+  var succ = function (dict) {
+      return dict.succ;
+  }; 
+  var pred = function (dict) {
+      return dict.pred;
+  };              
+  var fromEnum = function (dict) {
+      return dict.fromEnum;
+  };
+  var toEnumWithDefaults = function (dictBoundedEnum) {
+      return function (low) {
+          return function (high) {
+              return function (x) {
+                  var v = toEnum(dictBoundedEnum)(x);
+                  if (v instanceof Data_Maybe.Just) {
+                      return v.value0;
+                  };
+                  if (v instanceof Data_Maybe.Nothing) {
+                      var $51 = x < fromEnum(dictBoundedEnum)(Data_Bounded.bottom(dictBoundedEnum.Bounded0()));
+                      if ($51) {
+                          return low;
+                      };
+                      return high;
+                  };
+                  throw new Error("Failed pattern match at Data.Enum line 158, column 33 - line 160, column 62: " + [ v.constructor.name ]);
+              };
+          };
       };
-  });
-  var applyIdentity = new Control_Apply.Apply(function () {
-      return functorIdentity;
-  }, function (v) {
-      return function (v1) {
-          return v(v1);
+  };
+  var defaultSucc = function (toEnum$prime) {
+      return function (fromEnum$prime) {
+          return function (a) {
+              return toEnum$prime(fromEnum$prime(a) + 1 | 0);
+          };
       };
-  });
-  var bindIdentity = new Control_Bind.Bind(function () {
-      return applyIdentity;
-  }, function (v) {
-      return function (f) {
-          return f(v);
+  };
+  var defaultPred = function (toEnum$prime) {
+      return function (fromEnum$prime) {
+          return function (a) {
+              return toEnum$prime(fromEnum$prime(a) - 1 | 0);
+          };
       };
-  });
-  var applicativeIdentity = new Control_Applicative.Applicative(function () {
-      return applyIdentity;
-  }, Identity);
-  var monadIdentity = new Control_Monad.Monad(function () {
-      return applicativeIdentity;
+  };
+  var charToEnum = function (v) {
+      if (v >= Data_Bounded.bottom(Data_Bounded.boundedInt) && v <= Data_Bounded.top(Data_Bounded.boundedInt)) {
+          return new Data_Maybe.Just($foreign.fromCharCode(v));
+      };
+      return Data_Maybe.Nothing.value;
+  };
+  var enumChar = new Enum(function () {
+      return Data_Ord.ordChar;
+  }, defaultPred(charToEnum)($foreign.toCharCode), defaultSucc(charToEnum)($foreign.toCharCode));
+  var cardinality = function (dict) {
+      return dict.cardinality;
+  }; 
+  var boundedEnumChar = new BoundedEnum(function () {
+      return Data_Bounded.boundedChar;
   }, function () {
-      return bindIdentity;
-  });
-  exports["Identity"] = Identity;
-  exports["newtypeIdentity"] = newtypeIdentity;
-  exports["functorIdentity"] = functorIdentity;
-  exports["applyIdentity"] = applyIdentity;
-  exports["applicativeIdentity"] = applicativeIdentity;
-  exports["bindIdentity"] = bindIdentity;
-  exports["monadIdentity"] = monadIdentity;
-})(PS["Data.Identity"] = PS["Data.Identity"] || {});
+      return enumChar;
+  }, $foreign.toCharCode(Data_Bounded.top(Data_Bounded.boundedChar)) - $foreign.toCharCode(Data_Bounded.bottom(Data_Bounded.boundedChar)) | 0, $foreign.toCharCode, charToEnum);
+  exports["Enum"] = Enum;
+  exports["succ"] = succ;
+  exports["pred"] = pred;
+  exports["BoundedEnum"] = BoundedEnum;
+  exports["cardinality"] = cardinality;
+  exports["toEnum"] = toEnum;
+  exports["fromEnum"] = fromEnum;
+  exports["toEnumWithDefaults"] = toEnumWithDefaults;
+  exports["defaultSucc"] = defaultSucc;
+  exports["defaultPred"] = defaultPred;
+  exports["enumChar"] = enumChar;
+  exports["boundedEnumChar"] = boundedEnumChar;
+})(PS["Data.Enum"] = PS["Data.Enum"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.runFn4 = function (fn) {
+    return function (a) {
+      return function (b) {
+        return function (c) {
+          return function (d) {
+            return fn(a, b, c, d);
+          };
+        };
+      };
+    };
+  };
+})(PS["Data.Function.Uncurried"] = PS["Data.Function.Uncurried"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
-  var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Either = PS["Data.Either"];
-  var Data_Identity = PS["Data.Identity"];
-  var Data_Newtype = PS["Data.Newtype"];
-  var Prelude = PS["Prelude"];                                                           
-  var runExcept = function ($0) {
-      return Data_Newtype.unwrap(Data_Identity.newtypeIdentity)(Control_Monad_Except_Trans.runExceptT($0));
+  var $foreign = PS["Data.Function.Uncurried"];
+  var Data_Unit = PS["Data.Unit"];
+  exports["runFn4"] = $foreign.runFn4;
+})(PS["Data.Function.Uncurried"] = PS["Data.Function.Uncurried"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Data_Maybe = PS["Data.Maybe"];                 
+  var Inl = (function () {
+      function Inl(value0) {
+          this.value0 = value0;
+      };
+      Inl.create = function (value0) {
+          return new Inl(value0);
+      };
+      return Inl;
+  })();
+  var Inr = (function () {
+      function Inr(value0) {
+          this.value0 = value0;
+      };
+      Inr.create = function (value0) {
+          return new Inr(value0);
+      };
+      return Inr;
+  })();
+  var Constructor = function (x) {
+      return x;
   };
-  var mapExcept = function (f) {
-      return Control_Monad_Except_Trans.mapExceptT(function ($1) {
-          return Data_Identity.Identity(f(Data_Newtype.unwrap(Data_Identity.newtypeIdentity)($1)));
-      });
+  var Generic = function (from, to) {
+      this.from = from;
+      this.to = to;
   };
-  exports["runExcept"] = runExcept;
-  exports["mapExcept"] = mapExcept;
-})(PS["Control.Monad.Except"] = PS["Control.Monad.Except"] || {});
+  var to = function (dict) {
+      return dict.to;
+  }; 
+  var from = function (dict) {
+      return dict.from;
+  };
+  exports["Generic"] = Generic;
+  exports["to"] = to;
+  exports["from"] = from;
+  exports["Inl"] = Inl;
+  exports["Inr"] = Inr;
+  exports["Constructor"] = Constructor;
+})(PS["Data.Generic.Rep"] = PS["Data.Generic.Rep"] || {});
 (function(exports) {
     "use strict";
 
-  // module Data.Int
-
   exports.fromNumberImpl = function (just) {
     return function (nothing) {
       return function (n) {
@@ -1910,15 +2949,13 @@ var PS = {};
   /* globals exports */
   "use strict";         
 
-  exports.infinity = Infinity;  
-  exports.decodeURIComponent = decodeURIComponent;
+  exports.infinity = Infinity;
 })(PS["Global"] = PS["Global"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Global"];
   exports["infinity"] = $foreign.infinity;
-  exports["decodeURIComponent"] = $foreign["decodeURIComponent"];
 })(PS["Global"] = PS["Global"] || {});
 (function(exports) {
     "use strict";        
@@ -1926,25 +2963,30 @@ var PS = {};
   exports.floor = Math.floor;
 })(PS["Math"] = PS["Math"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Math"];
   exports["floor"] = $foreign.floor;
 })(PS["Math"] = PS["Math"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Data.Int"];
+  var Control_Category = PS["Control.Category"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
   var Data_Boolean = PS["Data.Boolean"];
   var Data_Bounded = PS["Data.Bounded"];
+  var Data_CommutativeRing = PS["Data.CommutativeRing"];
+  var Data_DivisionRing = PS["Data.DivisionRing"];
   var Data_Eq = PS["Data.Eq"];
+  var Data_EuclideanRing = PS["Data.EuclideanRing"];
   var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
   var Data_Int_Bits = PS["Data.Int.Bits"];
   var Data_Maybe = PS["Data.Maybe"];
   var Data_Ord = PS["Data.Ord"];
   var Data_Ordering = PS["Data.Ordering"];
   var Data_Ring = PS["Data.Ring"];
+  var Data_Semiring = PS["Data.Semiring"];
   var Data_Show = PS["Data.Show"];
   var Global = PS["Global"];
   var $$Math = PS["Math"];
@@ -1967,10 +3009,10 @@ var PS = {};
       if (Data_Boolean.otherwise) {
           return Data_Maybe.fromMaybe(0)(fromNumber(x));
       };
-      throw new Error("Failed pattern match at Data.Int line 64, column 1 - line 64, column 29: " + [ x.constructor.name ]);
+      throw new Error("Failed pattern match at Data.Int line 66, column 1 - line 66, column 29: " + [ x.constructor.name ]);
   };
-  var floor = function ($14) {
-      return unsafeClamp($$Math.floor($14));
+  var floor = function ($24) {
+      return unsafeClamp($$Math.floor($24));
   };
   exports["fromNumber"] = fromNumber;
   exports["floor"] = floor;
@@ -1979,7 +3021,7 @@ var PS = {};
   exports["toStringAs"] = $foreign.toStringAs;
 })(PS["Data.Int"] = PS["Data.Int"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Alt = PS["Control.Alt"];
   var Control_Alternative = PS["Control.Alternative"];
@@ -1987,16 +3029,26 @@ var PS = {};
   var Control_Apply = PS["Control.Apply"];
   var Control_Category = PS["Control.Category"];
   var Control_Plus = PS["Control.Plus"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
   var Data_Eq = PS["Data.Eq"];
   var Data_Foldable = PS["Data.Foldable"];
+  var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
+  var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
   var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Maybe = PS["Data.Maybe"];
   var Data_Ord = PS["Data.Ord"];
   var Data_Ordering = PS["Data.Ordering"];
   var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Semigroup_Foldable = PS["Data.Semigroup.Foldable"];
   var Data_Show = PS["Data.Show"];
   var Data_Traversable = PS["Data.Traversable"];
-  var Prelude = PS["Prelude"];        
+  var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Data_Unfoldable = PS["Data.Unfoldable"];
+  var Data_Unfoldable1 = PS["Data.Unfoldable1"];
+  var Prelude = PS["Prelude"];                 
   var NonEmpty = (function () {
       function NonEmpty(value0, value1) {
           this.value0 = value0;
@@ -2016,8 +3068,8 @@ var PS = {};
   };
   var functorNonEmpty = function (dictFunctor) {
       return new Data_Functor.Functor(function (f) {
-          return function (v) {
-              return new NonEmpty(f(v.value0), Data_Functor.map(dictFunctor)(f)(v.value1));
+          return function (m) {
+              return new NonEmpty(f(m.value0), Data_Functor.map(dictFunctor)(f)(m.value1));
           };
       });
   };
@@ -2048,7 +3100,7 @@ var PS = {};
   exports["foldableNonEmpty"] = foldableNonEmpty;
 })(PS["Data.NonEmpty"] = PS["Data.NonEmpty"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Alt = PS["Control.Alt"];
   var Control_Alternative = PS["Control.Alternative"];
@@ -2065,8 +3117,10 @@ var PS = {};
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
   var Data_Eq = PS["Data.Eq"];
   var Data_Foldable = PS["Data.Foldable"];
+  var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
   var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
   var Data_Maybe = PS["Data.Maybe"];
   var Data_Monoid = PS["Data.Monoid"];
@@ -2074,14 +3128,18 @@ var PS = {};
   var Data_NonEmpty = PS["Data.NonEmpty"];
   var Data_Ord = PS["Data.Ord"];
   var Data_Ordering = PS["Data.Ordering"];
+  var Data_Ring = PS["Data.Ring"];
   var Data_Semigroup = PS["Data.Semigroup"];
   var Data_Semigroup_Foldable = PS["Data.Semigroup.Foldable"];
   var Data_Semigroup_Traversable = PS["Data.Semigroup.Traversable"];
+  var Data_Semiring = PS["Data.Semiring"];
   var Data_Show = PS["Data.Show"];
   var Data_Traversable = PS["Data.Traversable"];
+  var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
   var Data_Tuple = PS["Data.Tuple"];
   var Data_Unfoldable = PS["Data.Unfoldable"];
-  var Prelude = PS["Prelude"];        
+  var Data_Unfoldable1 = PS["Data.Unfoldable1"];
+  var Prelude = PS["Prelude"];                 
   var Nil = (function () {
       function Nil() {
 
@@ -2110,8 +3168,8 @@ var PS = {};
   var foldableList = new Data_Foldable.Foldable(function (dictMonoid) {
       return function (f) {
           return Data_Foldable.foldl(foldableList)(function (acc) {
-              return function ($143) {
-                  return Data_Semigroup.append(dictMonoid.Semigroup0())(acc)(f($143));
+              return function ($174) {
+                  return Data_Semigroup.append(dictMonoid.Semigroup0())(acc)(f($174));
               };
           })(Data_Monoid.mempty(dictMonoid));
       };
@@ -2131,7 +3189,7 @@ var PS = {};
                       $copy_v = v.value1;
                       return;
                   };
-                  throw new Error("Failed pattern match at Data.List.Types line 78, column 12 - line 80, column 30: " + [ v.constructor.name ]);
+                  throw new Error("Failed pattern match at Data.List.Types line 81, column 12 - line 83, column 30: " + [ v.constructor.name ]);
               };
               while (!$tco_done) {
                   $tco_result = $tco_loop($tco_var_b, $copy_v);
@@ -2142,31 +3200,9 @@ var PS = {};
       return go;
   }, function (f) {
       return function (b) {
-          var rev = function ($copy_acc) {
-              return function ($copy_v) {
-                  var $tco_var_acc = $copy_acc;
-                  var $tco_done = false;
-                  var $tco_result;
-                  function $tco_loop(acc, v) {
-                      if (v instanceof Nil) {
-                          $tco_done = true;
-                          return acc;
-                      };
-                      if (v instanceof Cons) {
-                          $tco_var_acc = new Cons(v.value0, acc);
-                          $copy_v = v.value1;
-                          return;
-                      };
-                      throw new Error("Failed pattern match at Data.List.Types line 73, column 15 - line 75, column 33: " + [ v.constructor.name ]);
-                  };
-                  while (!$tco_done) {
-                      $tco_result = $tco_loop($tco_var_acc, $copy_v);
-                  };
-                  return $tco_result;
-              };
-          };
-          return function ($144) {
-              return Data_Foldable.foldl(foldableList)(Data_Function.flip(f))(b)(rev(Nil.value)($144));
+          var rev = Data_Foldable.foldl(foldableList)(Data_Function.flip(Cons.create))(Nil.value);
+          return function ($175) {
+              return Data_Foldable.foldl(foldableList)(Data_Function.flip(f))(b)(rev($175));
           };
       };
   });
@@ -2203,443 +3239,103 @@ var PS = {};
   exports["functorList"] = functorList;
   exports["foldableList"] = foldableList;
   exports["altList"] = altList;
-  exports["plusList"] = plusList;
-  exports["functorNonEmptyList"] = functorNonEmptyList;
-  exports["semigroupNonEmptyList"] = semigroupNonEmptyList;
-  exports["foldableNonEmptyList"] = foldableNonEmptyList;
-})(PS["Data.List.Types"] = PS["Data.List.Types"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Control_Alt = PS["Control.Alt"];
-  var Control_Alternative = PS["Control.Alternative"];
-  var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
-  var Control_Bind = PS["Control.Bind"];
-  var Control_Category = PS["Control.Category"];
-  var Control_Lazy = PS["Control.Lazy"];
-  var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Bifunctor = PS["Data.Bifunctor"];
-  var Data_Boolean = PS["Data.Boolean"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_Foldable = PS["Data.Foldable"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
-  var Data_List_Types = PS["Data.List.Types"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_Newtype = PS["Data.Newtype"];
-  var Data_NonEmpty = PS["Data.NonEmpty"];
-  var Data_Ord = PS["Data.Ord"];
-  var Data_Ordering = PS["Data.Ordering"];
-  var Data_Ring = PS["Data.Ring"];
-  var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Semiring = PS["Data.Semiring"];
-  var Data_Show = PS["Data.Show"];
-  var Data_Traversable = PS["Data.Traversable"];
-  var Data_Tuple = PS["Data.Tuple"];
-  var Data_Unfoldable = PS["Data.Unfoldable"];
-  var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];
-  var singleton = function (a) {
-      return new Data_List_Types.Cons(a, Data_List_Types.Nil.value);
-  };
-  var $$null = function (v) {
-      if (v instanceof Data_List_Types.Nil) {
-          return true;
-      };
-      return false;
-  };
-  var fromFoldable = function (dictFoldable) {
-      return Data_Foldable.foldr(dictFoldable)(Data_List_Types.Cons.create)(Data_List_Types.Nil.value);
-  };
-  exports["fromFoldable"] = fromFoldable;
-  exports["singleton"] = singleton;
-  exports["null"] = $$null;
-})(PS["Data.List"] = PS["Data.List"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Control_Bind = PS["Control.Bind"];
-  var Control_Category = PS["Control.Category"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Boolean = PS["Data.Boolean"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_Foldable = PS["Data.Foldable"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_List = PS["Data.List"];
-  var Data_List_Types = PS["Data.List.Types"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_NonEmpty = PS["Data.NonEmpty"];
-  var Data_Ord = PS["Data.Ord"];
-  var Data_Ring = PS["Data.Ring"];
-  var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Semigroup_Foldable = PS["Data.Semigroup.Foldable"];
-  var Data_Semigroup_Traversable = PS["Data.Semigroup.Traversable"];
-  var Data_Semiring = PS["Data.Semiring"];
-  var Data_Traversable = PS["Data.Traversable"];
-  var Data_Tuple = PS["Data.Tuple"];
-  var Data_Unfoldable = PS["Data.Unfoldable"];
-  var Partial_Unsafe = PS["Partial.Unsafe"];
-  var Prelude = PS["Prelude"];
-  var singleton = function ($160) {
-      return Data_List_Types.NonEmptyList(Data_NonEmpty.singleton(Data_List_Types.plusList)($160));
-  };
-  exports["singleton"] = singleton;
-})(PS["Data.List.NonEmpty"] = PS["Data.List.NonEmpty"] || {});
-(function(exports) {
-    "use strict";
-
-  exports.length = function (s) {
-    return s.length;
-  };
-
-  exports.replace = function (s1) {
-    return function (s2) {
-      return function (s3) {
-        return s3.replace(s1, s2);
-      };
-    };
-  };
-
-  exports.replaceAll = function (s1) {
-    return function (s2) {
-      return function (s3) {
-        return s3.replace(new RegExp(s1.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&"), "g"), s2);
-      };
-    };
-  };
-
-  exports.take = function (n) {
-    return function (s) {
-      return s.substr(0, n);
-    };
-  };
-
-  exports.drop = function (n) {
-    return function (s) {
-      return s.substring(n);
-    };
-  };
-
-  exports.split = function (sep) {
-    return function (s) {
-      return s.split(sep);
-    };
-  };
-
-  exports.joinWith = function (s) {
-    return function (xs) {
-      return xs.join(s);
-    };
-  };
-})(PS["Data.String"] = PS["Data.String"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Data.String"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_Newtype = PS["Data.Newtype"];
-  var Data_Ord = PS["Data.Ord"];
-  var Data_Ordering = PS["Data.Ordering"];
-  var Data_Ring = PS["Data.Ring"];
-  var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Semiring = PS["Data.Semiring"];
-  var Data_Show = PS["Data.Show"];
-  var Data_String_Unsafe = PS["Data.String.Unsafe"];
-  var Prelude = PS["Prelude"];        
-  var Replacement = function (x) {
-      return x;
-  };
-  var Pattern = function (x) {
-      return x;
-  };
-  var newtypeReplacement = new Data_Newtype.Newtype(function (n) {
-      return n;
-  }, Replacement);
-  var newtypePattern = new Data_Newtype.Newtype(function (n) {
-      return n;
-  }, Pattern);
-  exports["Pattern"] = Pattern;
-  exports["Replacement"] = Replacement;
-  exports["newtypePattern"] = newtypePattern;
-  exports["newtypeReplacement"] = newtypeReplacement;
-  exports["length"] = $foreign.length;
-  exports["replaceAll"] = $foreign.replaceAll;
-  exports["take"] = $foreign.take;
-  exports["drop"] = $foreign.drop;
-  exports["split"] = $foreign.split;
-  exports["joinWith"] = $foreign.joinWith;
-})(PS["Data.String"] = PS["Data.String"] || {});
+  exports["plusList"] = plusList;
+  exports["functorNonEmptyList"] = functorNonEmptyList;
+  exports["semigroupNonEmptyList"] = semigroupNonEmptyList;
+  exports["foldableNonEmptyList"] = foldableNonEmptyList;
+})(PS["Data.List.Types"] = PS["Data.List.Types"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.Foreign"];
+  var Control_Alt = PS["Control.Alt"];
+  var Control_Alternative = PS["Control.Alternative"];
   var Control_Applicative = PS["Control.Applicative"];
-  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
-  var Control_Monad_Except = PS["Control.Monad.Except"];
-  var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Lazy = PS["Control.Lazy"];
+  var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Bifunctor = PS["Data.Bifunctor"];
   var Data_Boolean = PS["Data.Boolean"];
-  var Data_Either = PS["Data.Either"];
   var Data_Eq = PS["Data.Eq"];
+  var Data_Foldable = PS["Data.Foldable"];
   var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
   var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
-  var Data_Identity = PS["Data.Identity"];
-  var Data_Int = PS["Data.Int"];
-  var Data_List_NonEmpty = PS["Data.List.NonEmpty"];
+  var Data_List_Types = PS["Data.List.Types"];
   var Data_Maybe = PS["Data.Maybe"];
+  var Data_Newtype = PS["Data.Newtype"];
+  var Data_NonEmpty = PS["Data.NonEmpty"];
   var Data_Ord = PS["Data.Ord"];
   var Data_Ordering = PS["Data.Ordering"];
+  var Data_Ring = PS["Data.Ring"];
   var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Semiring = PS["Data.Semiring"];
   var Data_Show = PS["Data.Show"];
-  var Data_String = PS["Data.String"];
-  var Prelude = PS["Prelude"];        
-  var ForeignError = (function () {
-      function ForeignError(value0) {
-          this.value0 = value0;
-      };
-      ForeignError.create = function (value0) {
-          return new ForeignError(value0);
-      };
-      return ForeignError;
-  })();
-  var TypeMismatch = (function () {
-      function TypeMismatch(value0, value1) {
-          this.value0 = value0;
-          this.value1 = value1;
-      };
-      TypeMismatch.create = function (value0) {
-          return function (value1) {
-              return new TypeMismatch(value0, value1);
-          };
-      };
-      return TypeMismatch;
-  })();
-  var ErrorAtIndex = (function () {
-      function ErrorAtIndex(value0, value1) {
-          this.value0 = value0;
-          this.value1 = value1;
-      };
-      ErrorAtIndex.create = function (value0) {
-          return function (value1) {
-              return new ErrorAtIndex(value0, value1);
-          };
-      };
-      return ErrorAtIndex;
-  })();
-  var ErrorAtProperty = (function () {
-      function ErrorAtProperty(value0, value1) {
-          this.value0 = value0;
-          this.value1 = value1;
-      };
-      ErrorAtProperty.create = function (value0) {
-          return function (value1) {
-              return new ErrorAtProperty(value0, value1);
-          };
-      };
-      return ErrorAtProperty;
-  })();
-  var JSONError = (function () {
-      function JSONError(value0) {
-          this.value0 = value0;
-      };
-      JSONError.create = function (value0) {
-          return new JSONError(value0);
-      };
-      return JSONError;
-  })();
-  var showForeignError = new Data_Show.Show(function (v) {
-      if (v instanceof ForeignError) {
-          return "(ForeignError " + (Data_Show.show(Data_Show.showString)(v.value0) + ")");
-      };
-      if (v instanceof ErrorAtIndex) {
-          return "(ErrorAtIndex " + (Data_Show.show(Data_Show.showInt)(v.value0) + (" " + (Data_Show.show(showForeignError)(v.value1) + ")")));
-      };
-      if (v instanceof ErrorAtProperty) {
-          return "(ErrorAtProperty " + (Data_Show.show(Data_Show.showString)(v.value0) + (" " + (Data_Show.show(showForeignError)(v.value1) + ")")));
-      };
-      if (v instanceof JSONError) {
-          return "(JSONError " + (Data_Show.show(Data_Show.showString)(v.value0) + ")");
-      };
-      if (v instanceof TypeMismatch) {
-          return "(TypeMismatch " + (Data_Show.show(Data_Show.showString)(v.value0) + (" " + (Data_Show.show(Data_Show.showString)(v.value1) + ")")));
-      };
-      throw new Error("Failed pattern match at Data.Foreign line 64, column 1 - line 64, column 47: " + [ v.constructor.name ]);
-  });
-  var renderForeignError = function (v) {
-      if (v instanceof ForeignError) {
-          return v.value0;
-      };
-      if (v instanceof ErrorAtIndex) {
-          return "Error at array index " + (Data_Show.show(Data_Show.showInt)(v.value0) + (": " + Data_Show.show(showForeignError)(v.value1)));
-      };
-      if (v instanceof ErrorAtProperty) {
-          return "Error at property " + (Data_Show.show(Data_Show.showString)(v.value0) + (": " + Data_Show.show(showForeignError)(v.value1)));
-      };
-      if (v instanceof JSONError) {
-          return "JSON error: " + v.value0;
-      };
-      if (v instanceof TypeMismatch) {
-          return "Type mismatch: expected " + (v.value0 + (", found " + v.value1));
-      };
-      throw new Error("Failed pattern match at Data.Foreign line 74, column 1 - line 74, column 45: " + [ v.constructor.name ]);
-  };
-  var fail = function ($121) {
-      return Control_Monad_Error_Class.throwError(Control_Monad_Except_Trans.monadThrowExceptT(Data_Identity.monadIdentity))(Data_List_NonEmpty.singleton($121));
+  var Data_Traversable = PS["Data.Traversable"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Data_Unfoldable = PS["Data.Unfoldable"];
+  var Data_Unit = PS["Data.Unit"];
+  var Prelude = PS["Prelude"];
+  var singleton = function (a) {
+      return new Data_List_Types.Cons(a, Data_List_Types.Nil.value);
   };
-  var readArray = function (value) {
-      if ($foreign.isArray(value)) {
-          return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))($foreign.unsafeFromForeign(value));
-      };
-      if (Data_Boolean.otherwise) {
-          return fail(new TypeMismatch("array", $foreign.tagOf(value)));
+  var $$null = function (v) {
+      if (v instanceof Data_List_Types.Nil) {
+          return true;
       };
-      throw new Error("Failed pattern match at Data.Foreign line 145, column 1 - line 145, column 42: " + [ value.constructor.name ]);
+      return false;
   };
-  var unsafeReadTagged = function (tag) {
-      return function (value) {
-          if ($foreign.tagOf(value) === tag) {
-              return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))($foreign.unsafeFromForeign(value));
-          };
-          if (Data_Boolean.otherwise) {
-              return fail(new TypeMismatch(tag, $foreign.tagOf(value)));
-          };
-          throw new Error("Failed pattern match at Data.Foreign line 104, column 1 - line 104, column 55: " + [ tag.constructor.name, value.constructor.name ]);
-      };
-  };                                            
-  var readNumber = unsafeReadTagged("Number");
-  var readInt = function (value) {
-      var error = Data_Either.Left.create(Data_List_NonEmpty.singleton(new TypeMismatch("Int", $foreign.tagOf(value))));
-      var fromNumber = function ($122) {
-          return Data_Maybe.maybe(error)(Control_Applicative.pure(Data_Either.applicativeEither))(Data_Int.fromNumber($122));
-      };
-      return Control_Monad_Except.mapExcept(Data_Either.either(Data_Function["const"](error))(fromNumber))(readNumber(value));
+  var fromFoldable = function (dictFoldable) {
+      return Data_Foldable.foldr(dictFoldable)(Data_List_Types.Cons.create)(Data_List_Types.Nil.value);
   };
-  var readString = unsafeReadTagged("String");
-  exports["ForeignError"] = ForeignError;
-  exports["TypeMismatch"] = TypeMismatch;
-  exports["ErrorAtIndex"] = ErrorAtIndex;
-  exports["ErrorAtProperty"] = ErrorAtProperty;
-  exports["JSONError"] = JSONError;
-  exports["renderForeignError"] = renderForeignError;
-  exports["unsafeReadTagged"] = unsafeReadTagged;
-  exports["readString"] = readString;
-  exports["readNumber"] = readNumber;
-  exports["readInt"] = readInt;
-  exports["readArray"] = readArray;
-  exports["fail"] = fail;
-  exports["showForeignError"] = showForeignError;
-  exports["typeOf"] = $foreign.typeOf;
-  exports["isNull"] = $foreign.isNull;
-  exports["isUndefined"] = $foreign.isUndefined;
-})(PS["Data.Foreign"] = PS["Data.Foreign"] || {});
+  exports["fromFoldable"] = fromFoldable;
+  exports["singleton"] = singleton;
+  exports["null"] = $$null;
+})(PS["Data.List"] = PS["Data.List"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Control.Monad.Eff.JQuery"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var DOM = PS["DOM"];
-  var Data_Foreign = PS["Data.Foreign"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Boolean = PS["Data.Boolean"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
+  var Data_List = PS["Data.List"];
+  var Data_List_Types = PS["Data.List.Types"];
   var Data_Maybe = PS["Data.Maybe"];
+  var Data_NonEmpty = PS["Data.NonEmpty"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ring = PS["Data.Ring"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Semigroup_Foldable = PS["Data.Semigroup.Foldable"];
+  var Data_Semigroup_Traversable = PS["Data.Semigroup.Traversable"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Traversable = PS["Data.Traversable"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Data_Unfoldable = PS["Data.Unfoldable"];
+  var Partial_Unsafe = PS["Partial.Unsafe"];
   var Prelude = PS["Prelude"];
-  var hide = $foreign.setVisible(false);  
-  var addClass = function (cls) {
-      return $foreign.setClass(cls)(true);
-  };
-  exports["addClass"] = addClass;
-  exports["hide"] = hide;
-  exports["ready"] = $foreign.ready;
-  exports["select"] = $foreign.select;
-  exports["create"] = $foreign.create;
-  exports["setAttr"] = $foreign.setAttr;
-  exports["attr"] = $foreign.attr;
-  exports["setProp"] = $foreign.setProp;
-  exports["append"] = $foreign.append;
-  exports["setText"] = $foreign.setText;
-  exports["setValue"] = $foreign.setValue;
-  exports["on"] = $foreign.on;
-})(PS["Control.Monad.Eff.JQuery"] = PS["Control.Monad.Eff.JQuery"] || {});
-(function(exports) {
-    "use strict";
-
-  exports.empty = function(jq) {
-    return function() {
-      jq.empty();
-    };
-  };
-
-  exports.fadeIn = function(jq) {
-    return function() {
-      jq.fadeIn();
-    };
-  };
-
-  exports.fadeOut = function(jq) {
-    return function() {
-      jq.fadeOut();
-    };
-  };
-
-  exports.filter = function(jq) {
-    return function(sel) {
-      return function() {
-        return jq.filter(sel);
-      };
-    };
-  };
-
-  exports.is = function(jq) {
-    return function(sel) {
-      return function() {
-        return jq.is(sel);
-      };
-    };
-  };
-
-  exports.getValue = function(jq) {
-    return function() {
-      return jq.val();
-    };
-  };
-})(PS["Control.Monad.Eff.JQuery.Extras"] = PS["Control.Monad.Eff.JQuery.Extras"] || {});
-(function(exports) {
-    "use strict";        
-
-  exports.nullable = function (a, r, f) {
-    return a == null ? r : f(a);
-  };
-})(PS["Data.Nullable"] = PS["Data.Nullable"] || {});
-(function(exports) {
-    "use strict";
-
-  exports.runFn4 = function (fn) {
-    return function (a) {
-      return function (b) {
-        return function (c) {
-          return function (d) {
-            return fn(a, b, c, d);
-          };
-        };
-      };
-    };
+  var singleton = function ($165) {
+      return Data_List_Types.NonEmptyList(Data_NonEmpty.singleton(Data_List_Types.plusList)($165));
   };
-})(PS["Data.Function.Uncurried"] = PS["Data.Function.Uncurried"] || {});
+  exports["singleton"] = singleton;
+})(PS["Data.List.NonEmpty"] = PS["Data.List.NonEmpty"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Data.Function.Uncurried"];
-  var Data_Unit = PS["Data.Unit"];
-  exports["runFn4"] = $foreign.runFn4;
-})(PS["Data.Function.Uncurried"] = PS["Data.Function.Uncurried"] || {});
+    "use strict";        
+
+  exports.nullable = function (a, r, f) {
+    return a == null ? r : f(a);
+  };
+})(PS["Data.Nullable"] = PS["Data.Nullable"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Data.Nullable"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
@@ -2655,893 +3351,693 @@ var PS = {};
   };
   exports["toMaybe"] = toMaybe;
 })(PS["Data.Nullable"] = PS["Data.Nullable"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Control.Monad.Eff.JQuery.Extras"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Monad_Eff_JQuery = PS["Control.Monad.Eff.JQuery"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var DOM = PS["DOM"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_Nullable = PS["Data.Nullable"];
-  var Prelude = PS["Prelude"];        
-  var getValueMaybe = function ($0) {
-      return Data_Functor.map(Control_Monad_Eff.functorEff)(Data_Nullable.toMaybe)($foreign.getValue($0));
-  };
-  exports["getValueMaybe"] = getValueMaybe;
-  exports["empty"] = $foreign.empty;
-  exports["fadeIn"] = $foreign.fadeIn;
-  exports["fadeOut"] = $foreign.fadeOut;
-  exports["filter"] = $foreign.filter;
-  exports["is"] = $foreign.is;
-})(PS["Control.Monad.Eff.JQuery.Extras"] = PS["Control.Monad.Eff.JQuery.Extras"] || {});
-(function(exports) {
-    "use strict";
-
-  exports.random = Math.random;
-})(PS["Control.Monad.Eff.Random"] = PS["Control.Monad.Eff.Random"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Control.Monad.Eff.Random"];
-  var Control_Applicative = PS["Control.Applicative"];
-  var Control_Bind = PS["Control.Bind"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Int = PS["Data.Int"];
-  var Data_Ord = PS["Data.Ord"];
-  var Data_Ring = PS["Data.Ring"];
-  var Data_Semiring = PS["Data.Semiring"];
-  var Prelude = PS["Prelude"];
-  var randomInt = function (low) {
-      return function (high) {
-          return function __do() {
-              var v = $foreign.random();
-              var asNumber = ((Data_Int.toNumber(high) - Data_Int.toNumber(low)) + 1) * v + Data_Int.toNumber(low);
-              return Data_Int.floor(asNumber);
-          };
-      };
-  };
-  exports["randomInt"] = randomInt;
-})(PS["Control.Monad.Eff.Random"] = PS["Control.Monad.Eff.Random"] || {});
 (function(exports) {
     "use strict";
-
-  exports.newRef = function (val) {
-    return function () {
-      return { value: val };
-    };
-  };
-
-  exports.readRef = function (ref) {
-    return function () {
-      return ref.value;
-    };
-  };
-
-  exports.writeRef = function (ref) {
-    return function (val) {
-      return function () {
-        ref.value = val;
-        return {};
-      };
+  /* global Symbol */
+
+  var hasArrayFrom = typeof Array.from === "function";
+  var hasStringIterator =
+    typeof Symbol !== "undefined" &&
+    Symbol != null &&
+    typeof Symbol.iterator !== "undefined" &&
+    typeof String.prototype[Symbol.iterator] === "function";
+  var hasFromCodePoint = typeof String.prototype.fromCodePoint === "function";
+  var hasCodePointAt = typeof String.prototype.codePointAt === "function";
+
+  exports._unsafeCodePointAt0 = function (fallback) {
+    return hasCodePointAt
+      ? function (str) { return str.codePointAt(0); }
+      : fallback;
+  };
+
+  exports._singleton = function (fallback) {
+    return hasFromCodePoint ? String.fromCodePoint : fallback;
+  };
+
+  exports._take = function (fallback) {
+    return function (n) {
+      if (hasStringIterator) {
+        return function (str) {
+          var accum = "";
+          var iter = str[Symbol.iterator]();
+          for (var i = 0; i < n; ++i) {
+            var o = iter.next();
+            if (o.done) return accum;
+            accum += o.value;
+          }
+          return accum;
+        };
+      }
+      return fallback(n);
     };
   };
-})(PS["Control.Monad.Eff.Ref"] = PS["Control.Monad.Eff.Ref"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Control.Monad.Eff.Ref"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];
-  exports["newRef"] = $foreign.newRef;
-  exports["readRef"] = $foreign.readRef;
-  exports["writeRef"] = $foreign.writeRef;
-})(PS["Control.Monad.Eff.Ref"] = PS["Control.Monad.Eff.Ref"] || {});
-(function(exports) {
-  /* global exports */
-  "use strict";
 
-  exports.setTimeout = function (ms) {
-    return function (fn) {
-      return function () {
-        return setTimeout(fn, ms);
-      };
+  exports._toCodePointArray = function (fallback) {
+    return function (unsafeCodePointAt0) {
+      if (hasArrayFrom) {
+        return function (str) {
+          return Array.from(str, unsafeCodePointAt0);
+        };
+      }
+      return fallback;
     };
   };
-})(PS["Control.Monad.Eff.Timer"] = PS["Control.Monad.Eff.Timer"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Control.Monad.Eff.Timer"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_Ord = PS["Data.Ord"];
-  var Prelude = PS["Prelude"];
-  exports["setTimeout"] = $foreign.setTimeout;
-})(PS["Control.Monad.Eff.Timer"] = PS["Control.Monad.Eff.Timer"] || {});
+})(PS["Data.String.CodePoints"] = PS["Data.String.CodePoints"] || {});
 (function(exports) {
     "use strict";
 
-  exports.mkEffFn1 = function mkEffFn1(fn) {
-    return function(x) {
-      return fn(x)();
-    };
-  };
-
-  exports.runEffFn1 = function runEffFn1(fn) {
-    return function(a) {
-      return function() {
-        return fn(a);
-      };
-    };
-  };
-
-  exports.runEffFn2 = function runEffFn2(fn) {
-    return function(a) {
-      return function(b) {
-        return function() {
-          return fn(a, b);
-        };
-      };
-    };
-  };
-
-  exports.runEffFn3 = function runEffFn3(fn) {
-    return function(a) {
-      return function(b) {
-        return function(c) {
-          return function() {
-            return fn(a, b, c);
-          };
-        };
-      };
-    };
+  exports.singleton = function (c) {
+    return c;
   };
 
-  exports.runEffFn4 = function runEffFn4(fn) {
-    return function(a) {
-      return function(b) {
-        return function(c) {
-          return function(d) {
-            return function() {
-              return fn(a, b, c, d);
-            };
-          };
-        };
-      };
-    };
+  exports.length = function (s) {
+    return s.length;
   };
 
-  exports.runEffFn5 = function runEffFn5(fn) {
-    return function(a) {
-      return function(b) {
-        return function(c) {
-          return function(d) {
-            return function(e) {
-              return function() {
-                return fn(a, b, c, d, e);
-              };
-            };
-          };
-        };
-      };
+  exports.drop = function (n) {
+    return function (s) {
+      return s.substring(n);
     };
   };
-})(PS["Control.Monad.Eff.Uncurried"] = PS["Control.Monad.Eff.Uncurried"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Control.Monad.Eff.Uncurried"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  exports["mkEffFn1"] = $foreign.mkEffFn1;
-  exports["runEffFn1"] = $foreign.runEffFn1;
-  exports["runEffFn2"] = $foreign.runEffFn2;
-  exports["runEffFn3"] = $foreign.runEffFn3;
-  exports["runEffFn4"] = $foreign.runEffFn4;
-  exports["runEffFn5"] = $foreign.runEffFn5;
-})(PS["Control.Monad.Eff.Uncurried"] = PS["Control.Monad.Eff.Uncurried"] || {});
-(function(exports) {
-    "use strict";
-
-  exports.unsafeCoerceEff = function (f) {
-    return f;
-  };
-})(PS["Control.Monad.Eff.Unsafe"] = PS["Control.Monad.Eff.Unsafe"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Control.Monad.Eff.Unsafe"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  exports["unsafeCoerceEff"] = $foreign.unsafeCoerceEff;
-})(PS["Control.Monad.Eff.Unsafe"] = PS["Control.Monad.Eff.Unsafe"] || {});
+})(PS["Data.String.CodeUnits"] = PS["Data.String.CodeUnits"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Alt = PS["Control.Alt"];
-  var Control_Alternative = PS["Control.Alternative"];
-  var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
-  var Control_Bind = PS["Control.Bind"];
-  var Control_Comonad = PS["Control.Comonad"];
-  var Control_Extend = PS["Control.Extend"];
-  var Control_Lazy = PS["Control.Lazy"];
-  var Control_Monad = PS["Control.Monad"];
-  var Control_MonadPlus = PS["Control.MonadPlus"];
-  var Control_MonadZero = PS["Control.MonadZero"];
-  var Control_Plus = PS["Control.Plus"];
   var Data_Eq = PS["Data.Eq"];
-  var Data_Foldable = PS["Data.Foldable"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Monoid = PS["Data.Monoid"];
   var Data_Newtype = PS["Data.Newtype"];
   var Data_Ord = PS["Data.Ord"];
   var Data_Semigroup = PS["Data.Semigroup"];
   var Data_Show = PS["Data.Show"];
-  var Data_Traversable = PS["Data.Traversable"];
-  var Prelude = PS["Prelude"];
-  var Unsafe_Coerce = PS["Unsafe.Coerce"];        
-  var App = function (x) {
+  var Prelude = PS["Prelude"];                 
+  var Replacement = function (x) {
       return x;
   };
-  var semigroupApp = function (dictApply) {
-      return function (dictSemigroup) {
-          return new Data_Semigroup.Semigroup(function (v) {
-              return function (v1) {
-                  return Control_Apply.lift2(dictApply)(Data_Semigroup.append(dictSemigroup))(v)(v1);
-              };
-          });
-      };
-  };
-  var newtypeApp = new Data_Newtype.Newtype(function (n) {
+  var Pattern = function (x) {
+      return x;
+  }; 
+  var newtypeReplacement = new Data_Newtype.Newtype(function (n) {
       return n;
-  }, App);
-  var applicativeApp = function (dictApplicative) {
-      return dictApplicative;
+  }, Replacement);
+  var newtypePattern = new Data_Newtype.Newtype(function (n) {
+      return n;
+  }, Pattern);
+  exports["Pattern"] = Pattern;
+  exports["Replacement"] = Replacement;
+  exports["newtypePattern"] = newtypePattern;
+  exports["newtypeReplacement"] = newtypeReplacement;
+})(PS["Data.String.Pattern"] = PS["Data.String.Pattern"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.charAt = function (i) {
+    return function (s) {
+      if (i >= 0 && i < s.length) return s.charAt(i);
+      throw new Error("Data.String.Unsafe.charAt: Invalid index.");
+    };
   };
-  exports["App"] = App;
-  exports["newtypeApp"] = newtypeApp;
-  exports["semigroupApp"] = semigroupApp;
-  exports["applicativeApp"] = applicativeApp;
-})(PS["Data.Functor.App"] = PS["Data.Functor.App"] || {});
+})(PS["Data.String.Unsafe"] = PS["Data.String.Unsafe"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Alt = PS["Control.Alt"];
-  var Control_Alternative = PS["Control.Alternative"];
-  var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
-  var Control_Category = PS["Control.Category"];
-  var Control_Plus = PS["Control.Plus"];
+  var $foreign = PS["Data.String.Unsafe"];
+  exports["charAt"] = $foreign.charAt;
+})(PS["Data.String.Unsafe"] = PS["Data.String.Unsafe"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.String.CodeUnits"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Boolean = PS["Data.Boolean"];
   var Data_Eq = PS["Data.Eq"];
-  var Data_Foldable = PS["Data.Foldable"];
   var Data_Function = PS["Data.Function"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Functor_App = PS["Data.Functor.App"];
-  var Data_Newtype = PS["Data.Newtype"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Maybe = PS["Data.Maybe"];
   var Data_Ord = PS["Data.Ord"];
-  var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Show = PS["Data.Show"];
-  var Data_Traversable = PS["Data.Traversable"];
-  var Prelude = PS["Prelude"];        
-  var Compose = function (x) {
-      return x;
-  };          
-  var functorCompose = function (dictFunctor) {
-      return function (dictFunctor1) {
-          return new Data_Functor.Functor(function (f) {
-              return function (v) {
-                  return Compose(Data_Functor.map(dictFunctor)(Data_Functor.map(dictFunctor1)(f))(v));
-              };
-          });
+  var Data_Ring = PS["Data.Ring"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_String_Pattern = PS["Data.String.Pattern"];
+  var Data_String_Unsafe = PS["Data.String.Unsafe"];
+  var Prelude = PS["Prelude"];
+  exports["singleton"] = $foreign.singleton;
+  exports["length"] = $foreign.length;
+  exports["drop"] = $foreign.drop;
+})(PS["Data.String.CodeUnits"] = PS["Data.String.CodeUnits"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.replace = function (s1) {
+    return function (s2) {
+      return function (s3) {
+        return s3.replace(s1, s2);
       };
+    };
   };
-  var applyCompose = function (dictApply) {
-      return function (dictApply1) {
-          return new Control_Apply.Apply(function () {
-              return functorCompose(dictApply.Functor0())(dictApply1.Functor0());
-          }, function (v) {
-              return function (v1) {
-                  return Compose(Control_Apply.apply(dictApply)(Data_Functor.map(dictApply.Functor0())(Control_Apply.apply(dictApply1))(v))(v1));
-              };
-          });
+
+  exports.replaceAll = function (s1) {
+    return function (s2) {
+      return function (s3) {
+        return s3.replace(new RegExp(s1.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&"), "g"), s2); // eslint-disable-line no-useless-escape
       };
+    };
   };
-  var applicativeCompose = function (dictApplicative) {
-      return function (dictApplicative1) {
-          return new Control_Applicative.Applicative(function () {
-              return applyCompose(dictApplicative.Apply0())(dictApplicative1.Apply0());
-          }, function ($75) {
-              return Compose(Control_Applicative.pure(dictApplicative)(Control_Applicative.pure(dictApplicative1)($75)));
-          });
-      };
+
+  exports.split = function (sep) {
+    return function (s) {
+      return s.split(sep);
+    };
   };
-  exports["Compose"] = Compose;
-  exports["functorCompose"] = functorCompose;
-  exports["applyCompose"] = applyCompose;
-  exports["applicativeCompose"] = applicativeCompose;
-})(PS["Data.Functor.Compose"] = PS["Data.Functor.Compose"] || {});
+
+  exports.joinWith = function (s) {
+    return function (xs) {
+      return xs.join(s);
+    };
+  };
+})(PS["Data.String.Common"] = PS["Data.String.Common"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Alt = PS["Control.Alt"];
-  var Control_Alternative = PS["Control.Alternative"];
-  var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
-  var Control_Bind = PS["Control.Bind"];
-  var Control_Monad_Cont_Trans = PS["Control.Monad.Cont.Trans"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
-  var Control_Monad_Eff_Ref = PS["Control.Monad.Eff.Ref"];
-  var Control_Monad_Eff_Unsafe = PS["Control.Monad.Eff.Unsafe"];
-  var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
-  var Control_Monad_Maybe_Trans = PS["Control.Monad.Maybe.Trans"];
-  var Control_Monad_Reader_Trans = PS["Control.Monad.Reader.Trans"];
-  var Control_Monad_Writer_Trans = PS["Control.Monad.Writer.Trans"];
-  var Control_Plus = PS["Control.Plus"];
+  var $foreign = PS["Data.String.Common"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Ordering = PS["Data.Ordering"];
+  var Data_String_Pattern = PS["Data.String.Pattern"];
+  var Prelude = PS["Prelude"];
+  exports["replaceAll"] = $foreign.replaceAll;
+  exports["split"] = $foreign.split;
+  exports["joinWith"] = $foreign.joinWith;
+})(PS["Data.String.Common"] = PS["Data.String.Common"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.String.CodePoints"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Either = PS["Data.Either"];
-  var Data_Function = PS["Data.Function"];
+  var Data_Array = PS["Data.Array"];
+  var Data_Boolean = PS["Data.Boolean"];
+  var Data_Bounded = PS["Data.Bounded"];
+  var Data_Enum = PS["Data.Enum"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_EuclideanRing = PS["Data.EuclideanRing"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_Functor_Compose = PS["Data.Functor.Compose"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Int = PS["Data.Int"];
   var Data_Maybe = PS["Data.Maybe"];
-  var Data_Monoid = PS["Data.Monoid"];
-  var Data_Newtype = PS["Data.Newtype"];
-  var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];        
-  var ParCont = function (x) {
-      return x;
-  };
-  var Parallel = function (Applicative1, Monad0, parallel, sequential) {
-      this.Applicative1 = Applicative1;
-      this.Monad0 = Monad0;
-      this.parallel = parallel;
-      this.sequential = sequential;
-  };
-  var unsafeWithRef = Control_Monad_Eff_Unsafe.unsafeCoerceEff;
-  var sequential = function (dict) {
-      return dict.sequential;
-  };
-  var parallel = function (dict) {
-      return dict.parallel;
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ring = PS["Data.Ring"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Show = PS["Data.Show"];
+  var Data_String_CodeUnits = PS["Data.String.CodeUnits"];
+  var Data_String_Common = PS["Data.String.Common"];
+  var Data_String_Pattern = PS["Data.String.Pattern"];
+  var Data_String_Unsafe = PS["Data.String.Unsafe"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Data_Unfoldable = PS["Data.Unfoldable"];
+  var Prelude = PS["Prelude"];
+  var unsurrogate = function (lead) {
+      return function (trail) {
+          return (((lead - 55296 | 0) * 1024 | 0) + (trail - 56320 | 0) | 0) + 65536 | 0;
+      };
+  }; 
+  var isTrail = function (cu) {
+      return 56320 <= cu && cu <= 57343;
   };
-  var monadParExceptT = function (dictParallel) {
-      return new Parallel(function () {
-          return Data_Functor_Compose.applicativeCompose(dictParallel.Applicative1())(Data_Either.applicativeEither);
-      }, function () {
-          return Control_Monad_Except_Trans.monadExceptT(dictParallel.Monad0());
-      }, function (v) {
-          return parallel(dictParallel)(v);
-      }, function (v) {
-          return sequential(dictParallel)(v);
-      });
+  var isLead = function (cu) {
+      return 55296 <= cu && cu <= 56319;
   };
-  var monadParParCont = function (dictMonadEff) {
-      return new Parallel(function () {
-          return applicativeParCont(dictMonadEff);
-      }, function () {
-          return Control_Monad_Cont_Trans.monadContT(dictMonadEff.Monad0());
-      }, ParCont, function (v) {
-          return v;
+  var uncons = function (s) {
+      var v = Data_String_CodeUnits.length(s);
+      if (v === 0) {
+          return Data_Maybe.Nothing.value;
+      };
+      if (v === 1) {
+          return new Data_Maybe.Just({
+              head: Data_Enum.fromEnum(Data_Enum.boundedEnumChar)(Data_String_Unsafe.charAt(0)(s)),
+              tail: ""
+          });
+      };
+      var cu1 = Data_Enum.fromEnum(Data_Enum.boundedEnumChar)(Data_String_Unsafe.charAt(1)(s));
+      var cu0 = Data_Enum.fromEnum(Data_Enum.boundedEnumChar)(Data_String_Unsafe.charAt(0)(s));
+      var $21 = isLead(cu0) && isTrail(cu1);
+      if ($21) {
+          return new Data_Maybe.Just({
+              head: unsurrogate(cu0)(cu1),
+              tail: Data_String_CodeUnits.drop(2)(s)
+          });
+      };
+      return new Data_Maybe.Just({
+          head: cu0,
+          tail: Data_String_CodeUnits.drop(1)(s)
       });
   };
-  var functorParCont = function (dictMonadEff) {
-      return new Data_Functor.Functor(function (f) {
-          return function ($54) {
-              return parallel(monadParParCont(dictMonadEff))(Data_Functor.map(Control_Monad_Cont_Trans.functorContT((((dictMonadEff.Monad0()).Bind1()).Apply0()).Functor0()))(f)(sequential(monadParParCont(dictMonadEff))($54)));
+  var unconsButWithTuple = function (s) {
+      return Data_Functor.map(Data_Maybe.functorMaybe)(function (v) {
+          return new Data_Tuple.Tuple(v.head, v.tail);
+      })(uncons(s));
+  };
+  var toCodePointArrayFallback = function (s) {
+      return Data_Unfoldable.unfoldr(Data_Unfoldable.unfoldableArray)(unconsButWithTuple)(s);
+  };
+  var unsafeCodePointAt0Fallback = function (s) {
+      var cu1 = Data_Enum.fromEnum(Data_Enum.boundedEnumChar)(Data_String_Unsafe.charAt(1)(s));
+      var cu0 = Data_Enum.fromEnum(Data_Enum.boundedEnumChar)(Data_String_Unsafe.charAt(0)(s));
+      var $25 = isLead(cu0) && isTrail(cu1);
+      if ($25) {
+          return unsurrogate(cu0)(cu1);
+      };
+      return cu0;
+  };
+  var unsafeCodePointAt0 = $foreign._unsafeCodePointAt0(unsafeCodePointAt0Fallback);
+  var toCodePointArray = $foreign._toCodePointArray(toCodePointArrayFallback)(unsafeCodePointAt0);
+  var length = function ($51) {
+      return Data_Array.length(toCodePointArray($51));
+  };
+  var fromCharCode = function ($52) {
+      return Data_String_CodeUnits.singleton(Data_Enum.toEnumWithDefaults(Data_Enum.boundedEnumChar)(Data_Bounded.bottom(Data_Bounded.boundedChar))(Data_Bounded.top(Data_Bounded.boundedChar))($52));
+  };
+  var singletonFallback = function (v) {
+      if (v <= 65535) {
+          return fromCharCode(v);
+      };
+      var lead = Data_EuclideanRing.div(Data_EuclideanRing.euclideanRingInt)(v - 65536 | 0)(1024) + 55296 | 0;
+      var trail = Data_EuclideanRing.mod(Data_EuclideanRing.euclideanRingInt)(v - 65536 | 0)(1024) + 56320 | 0;
+      return fromCharCode(lead) + fromCharCode(trail);
+  };                                                                       
+  var singleton = $foreign._singleton(singletonFallback);
+  var takeFallback = function (n) {
+      return function (v) {
+          if (n < 1) {
+              return "";
           };
-      });
-  };
-  var applyParCont = function (dictMonadEff) {
-      return new Control_Apply.Apply(function () {
-          return functorParCont(dictMonadEff);
-      }, function (v) {
-          return function (v1) {
-              return ParCont(function (k) {
-                  return Control_Bind.bind((dictMonadEff.Monad0()).Bind1())(Control_Monad_Eff_Class.liftEff(dictMonadEff)(unsafeWithRef(Control_Monad_Eff_Ref.newRef(Data_Maybe.Nothing.value))))(function (v2) {
-                      return Control_Bind.bind((dictMonadEff.Monad0()).Bind1())(Control_Monad_Eff_Class.liftEff(dictMonadEff)(unsafeWithRef(Control_Monad_Eff_Ref.newRef(Data_Maybe.Nothing.value))))(function (v3) {
-                          return Control_Bind.discard(Control_Bind.discardUnit)((dictMonadEff.Monad0()).Bind1())(Control_Monad_Cont_Trans.runContT(v)(function (a) {
-                              return Control_Bind.bind((dictMonadEff.Monad0()).Bind1())(Control_Monad_Eff_Class.liftEff(dictMonadEff)(unsafeWithRef(Control_Monad_Eff_Ref.readRef(v3))))(function (v4) {
-                                  if (v4 instanceof Data_Maybe.Nothing) {
-                                      return Control_Monad_Eff_Class.liftEff(dictMonadEff)(unsafeWithRef(Control_Monad_Eff_Ref.writeRef(v2)(new Data_Maybe.Just(a))));
-                                  };
-                                  if (v4 instanceof Data_Maybe.Just) {
-                                      return k(a(v4.value0));
-                                  };
-                                  throw new Error("Failed pattern match at Control.Parallel.Class line 81, column 7 - line 83, column 26: " + [ v4.constructor.name ]);
-                              });
-                          }))(function () {
-                              return Control_Monad_Cont_Trans.runContT(v1)(function (b) {
-                                  return Control_Bind.bind((dictMonadEff.Monad0()).Bind1())(Control_Monad_Eff_Class.liftEff(dictMonadEff)(unsafeWithRef(Control_Monad_Eff_Ref.readRef(v2))))(function (v4) {
-                                      if (v4 instanceof Data_Maybe.Nothing) {
-                                          return Control_Monad_Eff_Class.liftEff(dictMonadEff)(unsafeWithRef(Control_Monad_Eff_Ref.writeRef(v3)(new Data_Maybe.Just(b))));
-                                      };
-                                      if (v4 instanceof Data_Maybe.Just) {
-                                          return k(v4.value0(b));
-                                      };
-                                      throw new Error("Failed pattern match at Control.Parallel.Class line 87, column 7 - line 89, column 26: " + [ v4.constructor.name ]);
-                                  });
-                              });
-                          });
-                      });
-                  });
-              });
+          var v1 = uncons(v);
+          if (v1 instanceof Data_Maybe.Just) {
+              return singleton(v1.value0.head) + takeFallback(n - 1 | 0)(v1.value0.tail);
           };
-      });
+          return v;
+      };
   };
-  var applicativeParCont = function (dictMonadEff) {
-      return new Control_Applicative.Applicative(function () {
-          return applyParCont(dictMonadEff);
-      }, function ($55) {
-          return parallel(monadParParCont(dictMonadEff))(Control_Applicative.pure(Control_Monad_Cont_Trans.applicativeContT((dictMonadEff.Monad0()).Applicative0()))($55));
-      });
+  var take = $foreign._take(takeFallback);
+  var drop = function (n) {
+      return function (s) {
+          return Data_String_CodeUnits.drop(Data_String_CodeUnits.length(take(n)(s)))(s);
+      };
   };
-  exports["Parallel"] = Parallel;
-  exports["parallel"] = parallel;
-  exports["sequential"] = sequential;
-  exports["ParCont"] = ParCont;
-  exports["monadParExceptT"] = monadParExceptT;
-  exports["functorParCont"] = functorParCont;
-  exports["applyParCont"] = applyParCont;
-  exports["applicativeParCont"] = applicativeParCont;
-  exports["monadParParCont"] = monadParParCont;
-})(PS["Control.Parallel.Class"] = PS["Control.Parallel.Class"] || {});
+  exports["singleton"] = singleton;
+  exports["toCodePointArray"] = toCodePointArray;
+  exports["uncons"] = uncons;
+  exports["length"] = length;
+  exports["take"] = take;
+  exports["drop"] = drop;
+})(PS["Data.String.CodePoints"] = PS["Data.String.CodePoints"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Control_Alternative = PS["Control.Alternative"];
-  var Control_Category = PS["Control.Category"];
-  var Control_Parallel_Class = PS["Control.Parallel.Class"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Foldable = PS["Data.Foldable"];
-  var Data_Traversable = PS["Data.Traversable"];
-  var Prelude = PS["Prelude"];
-  var parTraverse = function (dictParallel) {
-      return function (dictTraversable) {
-          return function (f) {
-              return function ($18) {
-                  return Control_Parallel_Class.sequential(dictParallel)(Data_Traversable.traverse(dictTraversable)(dictParallel.Applicative1())(function ($19) {
-                      return Control_Parallel_Class.parallel(dictParallel)(f($19));
-                  })($18));
-              };
-          };
+    "use strict";
+
+  exports["regex'"] = function (left) {
+    return function (right) {
+      return function (s1) {
+        return function (s2) {
+          try {
+            return right(new RegExp(s1, s2));
+          } catch (e) {
+            return left(e.message);
+          }
+        };
       };
+    };
   };
-  exports["parTraverse"] = parTraverse;
-})(PS["Control.Parallel"] = PS["Control.Parallel"] || {});
-(function(exports) {
-  /* global window */
-  "use strict";
 
-  exports.window = function () {
-    return window;
+  exports.replace = function (r) {
+    return function (s1) {
+      return function (s2) {
+        return s2.replace(r, s1);
+      };
+    };
+  };
+
+  exports["replace'"] = function (r) {
+    return function (f) {
+      return function (s2) {
+        return s2.replace(r, function (match) {
+          return f(match)(Array.prototype.splice.call(arguments, 1, arguments.length - 3));
+        });
+      };
+    };
   };
-})(PS["DOM.HTML"] = PS["DOM.HTML"] || {});
+})(PS["Data.String.Regex"] = PS["Data.String.Regex"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["DOM.HTML"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var DOM = PS["DOM"];
-  var DOM_HTML_Types = PS["DOM.HTML.Types"];
-  exports["window"] = $foreign.window;
-})(PS["DOM.HTML"] = PS["DOM.HTML"] || {});
+  var Control_MonadPlus = PS["Control.MonadPlus"];
+  var Control_MonadZero = PS["Control.MonadZero"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Show = PS["Data.Show"];
+  var Data_String = PS["Data.String"];
+  var Data_String_Common = PS["Data.String.Common"];
+  var Prelude = PS["Prelude"];                 
+  var RegexFlags = (function () {
+      function RegexFlags(value0) {
+          this.value0 = value0;
+      };
+      RegexFlags.create = function (value0) {
+          return new RegexFlags(value0);
+      };
+      return RegexFlags;
+  })();
+  var global = new RegexFlags({
+      global: true,
+      ignoreCase: false,
+      multiline: false,
+      sticky: false,
+      unicode: false
+  });
+  exports["RegexFlags"] = RegexFlags;
+  exports["global"] = global;
+})(PS["Data.String.Regex.Flags"] = PS["Data.String.Regex.Flags"] || {});
 (function(exports) {
-    "use strict";
-
-  // ----------------------------------------------------------------------------
-
-  exports.href = function (location) {
-    return function () {
-      return location.href;
-    };
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.String.Regex"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Array_NonEmpty = PS["Data.Array.NonEmpty"];
+  var Data_Either = PS["Data.Either"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Show = PS["Data.Show"];
+  var Data_String = PS["Data.String"];
+  var Data_String_CodeUnits = PS["Data.String.CodeUnits"];
+  var Data_String_Pattern = PS["Data.String.Pattern"];
+  var Data_String_Regex_Flags = PS["Data.String.Regex.Flags"];
+  var Prelude = PS["Prelude"];                                                    
+  var renderFlags = function (v) {
+      return (function () {
+          if (v.value0.global) {
+              return "g";
+          };
+          return "";
+      })() + ((function () {
+          if (v.value0.ignoreCase) {
+              return "i";
+          };
+          return "";
+      })() + ((function () {
+          if (v.value0.multiline) {
+              return "m";
+          };
+          return "";
+      })() + ((function () {
+          if (v.value0.sticky) {
+              return "y";
+          };
+          return "";
+      })() + (function () {
+          if (v.value0.unicode) {
+              return "u";
+          };
+          return "";
+      })())));
   };
-
-  exports.setHref = function (href) {
-    return function (location) {
-      return function () {
-        location.href = href;
+  var regex = function (s) {
+      return function (f) {
+          return $foreign["regex'"](Data_Either.Left.create)(Data_Either.Right.create)(s)(renderFlags(f));
       };
-    };
   };
-})(PS["DOM.HTML.Location"] = PS["DOM.HTML.Location"] || {});
+  exports["regex"] = regex;
+  exports["renderFlags"] = renderFlags;
+  exports["replace"] = $foreign.replace;
+  exports["replace'"] = $foreign["replace'"];
+})(PS["Data.String.Regex"] = PS["Data.String.Regex"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["DOM.HTML.Location"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var DOM = PS["DOM"];
-  var DOM_HTML_Types = PS["DOM.HTML.Types"];
-  var Prelude = PS["Prelude"];
-  exports["setHref"] = $foreign.setHref;
-})(PS["DOM.HTML.Location"] = PS["DOM.HTML.Location"] || {});
+  var Data_Either = PS["Data.Either"];
+  var Data_String_Regex = PS["Data.String.Regex"];
+  var Data_String_Regex_Flags = PS["Data.String.Regex.Flags"];
+  var Partial_Unsafe = PS["Partial.Unsafe"];                 
+  var unsafeRegex = function (s) {
+      return function (f) {
+          return Data_Either.fromRight()(Data_String_Regex.regex(s)(f));
+      };
+  };
+  exports["unsafeRegex"] = unsafeRegex;
+})(PS["Data.String.Regex.Unsafe"] = PS["Data.String.Regex.Unsafe"] || {});
 (function(exports) {
     "use strict";
 
-  exports.location = function (window) {
+  exports.error = function (s) {
     return function () {
-      return window.location;
-    };
-  };
-
-  exports.alert = function (str) {
-    return function (window) {
-      return function () {
-        window.alert(str);
-        return {};
-      };
-    };
-  };
-
-  exports.confirm = function (str) {
-    return function (window) {
-      return function () {
-        return window.confirm(str);
-      };
+      console.error(s);
+      return {};
     };
   };
-})(PS["DOM.HTML.Window"] = PS["DOM.HTML.Window"] || {});
+})(PS["Effect.Console"] = PS["Effect.Console"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["DOM.HTML.Window"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var DOM = PS["DOM"];
-  var DOM_HTML_Types = PS["DOM.HTML.Types"];
-  var DOM_WebStorage_Types = PS["DOM.WebStorage.Types"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_Newtype = PS["Data.Newtype"];
-  var Data_Nullable = PS["Data.Nullable"];
-  var Data_Ord = PS["Data.Ord"];
-  var Prelude = PS["Prelude"];
-  exports["location"] = $foreign.location;
-  exports["alert"] = $foreign.alert;
-  exports["confirm"] = $foreign.confirm;
-})(PS["DOM.HTML.Window"] = PS["DOM.HTML.Window"] || {});
+  var $foreign = PS["Effect.Console"];
+  var Data_Show = PS["Data.Show"];
+  var Data_Unit = PS["Data.Unit"];
+  var Effect = PS["Effect"];
+  exports["error"] = $foreign.error;
+})(PS["Effect.Console"] = PS["Effect.Console"] || {});
 (function(exports) {
     "use strict";
 
-  //------------------------------------------------------------------------------
-  // Array creation --------------------------------------------------------------
-  //------------------------------------------------------------------------------
-
-  exports.range = function (start) {
-    return function (end) {
-      var step = start > end ? -1 : 1;
-      var result = [];
-      var i = start, n = 0;
-      while (i !== end) {
-        result[n++] = i;
-        i += step;
-      }
-      result[n] = i;
-      return result;
-    };
-  };                    
-
-  exports.fromFoldableImpl = (function () {
-    // jshint maxparams: 2
-    function Cons(head, tail) {
-      this.head = head;
-      this.tail = tail;
-    }
-    var emptyList = {};
-
-    function curryCons(head) {
-      return function (tail) {
-        return new Cons(head, tail);
-      };
-    }
-
-    function listToArray(list) {
-      var result = [];
-      var count = 0;
-      var xs = list;
-      while (xs !== emptyList) {
-        result[count++] = xs.head;
-        xs = xs.tail;
-      }
-      return result;
-    }
-
-    return function (foldr) {
-      return function (xs) {
-        return listToArray(foldr(curryCons)(emptyList)(xs));
-      };
-    };
-  })();
-
-  //------------------------------------------------------------------------------
-  // Array size ------------------------------------------------------------------
-  //------------------------------------------------------------------------------
-
-  exports.length = function (xs) {
-    return xs.length;
-  };
-
-  //------------------------------------------------------------------------------
-  // Zipping ---------------------------------------------------------------------
-  //------------------------------------------------------------------------------
-
-  exports.zipWith = function (f) {
-    return function (xs) {
-      return function (ys) {
-        var l = xs.length < ys.length ? xs.length : ys.length;
-        var result = new Array(l);
-        for (var i = 0; i < l; i++) {
-          result[i] = f(xs[i])(ys[i]);
-        }
-        return result;
-      };
-    };
-  };
-})(PS["Data.Array"] = PS["Data.Array"] || {});
+  exports.random = Math.random;
+})(PS["Effect.Random"] = PS["Effect.Random"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.Array"];
-  var Control_Alt = PS["Control.Alt"];
-  var Control_Alternative = PS["Control.Alternative"];
+  var $foreign = PS["Effect.Random"];
   var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
-  var Control_Category = PS["Control.Category"];
-  var Control_Lazy = PS["Control.Lazy"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
-  var Control_Monad_ST = PS["Control.Monad.ST"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Array_ST = PS["Data.Array.ST"];
-  var Data_Array_ST_Iterator = PS["Data.Array.ST.Iterator"];
-  var Data_Boolean = PS["Data.Boolean"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_Foldable = PS["Data.Foldable"];
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_NonEmpty = PS["Data.NonEmpty"];
+  var Data_Int = PS["Data.Int"];
   var Data_Ord = PS["Data.Ord"];
-  var Data_Ordering = PS["Data.Ordering"];
   var Data_Ring = PS["Data.Ring"];
-  var Data_Semigroup = PS["Data.Semigroup"];
   var Data_Semiring = PS["Data.Semiring"];
-  var Data_Traversable = PS["Data.Traversable"];
-  var Data_Tuple = PS["Data.Tuple"];
-  var Data_Unfoldable = PS["Data.Unfoldable"];
-  var Partial_Unsafe = PS["Partial.Unsafe"];
+  var Effect = PS["Effect"];
   var Prelude = PS["Prelude"];
-  var singleton = function (a) {
-      return [ a ];
-  };
-  var fromFoldable = function (dictFoldable) {
-      return $foreign.fromFoldableImpl(Data_Foldable.foldr(dictFoldable));
-  };
-  var concatMap = Data_Function.flip(Control_Bind.bind(Control_Bind.bindArray));
-  var mapMaybe = function (f) {
-      return concatMap(function ($94) {
-          return Data_Maybe.maybe([  ])(singleton)(f($94));
-      });
+  var randomInt = function (low) {
+      return function (high) {
+          return function __do() {
+              var v = $foreign.random();
+              var asNumber = ((Data_Int.toNumber(high) - Data_Int.toNumber(low)) + 1) * v + Data_Int.toNumber(low);
+              return Data_Int.floor(asNumber);
+          };
+      };
   };
-  var catMaybes = mapMaybe(Control_Category.id(Control_Category.categoryFn));
-  exports["fromFoldable"] = fromFoldable;
-  exports["singleton"] = singleton;
-  exports["concatMap"] = concatMap;
-  exports["mapMaybe"] = mapMaybe;
-  exports["catMaybes"] = catMaybes;
-  exports["range"] = $foreign.range;
-  exports["length"] = $foreign.length;
-  exports["zipWith"] = $foreign.zipWith;
-})(PS["Data.Array"] = PS["Data.Array"] || {});
+  exports["randomInt"] = randomInt;
+})(PS["Effect.Random"] = PS["Effect.Random"] || {});
 (function(exports) {
-    "use strict";
+  /* global exports */
+  "use strict";
 
-  exports.mapWithIndexArray = function (f) {
-    return function (xs) {
-      var l = xs.length;
-      var result = Array(l);
-      for (var i = 0; i < l; i++) {
-        result[i] = f(i)(xs[i]);
-      }
-      return result;
+  exports.setTimeout = function (ms) {
+    return function (fn) {
+      return function () {
+        return setTimeout(fn, ms);
+      };
     };
   };
-})(PS["Data.FunctorWithIndex"] = PS["Data.FunctorWithIndex"] || {});
+})(PS["Effect.Timer"] = PS["Effect.Timer"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.FunctorWithIndex"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_Maybe_First = PS["Data.Maybe.First"];
-  var Data_Maybe_Last = PS["Data.Maybe.Last"];
-  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
-  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
-  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
-  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
-  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
-  var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];        
-  var FunctorWithIndex = function (Functor0, mapWithIndex) {
-      this.Functor0 = Functor0;
-      this.mapWithIndex = mapWithIndex;
+  var $foreign = PS["Effect.Timer"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Ord = PS["Data.Ord"];
+  var Effect = PS["Effect"];
+  var Prelude = PS["Prelude"];
+  exports["setTimeout"] = $foreign.setTimeout;
+})(PS["Effect.Timer"] = PS["Effect.Timer"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.unsafeFromForeign = function (value) {
+    return value;
   };
-  var mapWithIndex = function (dict) {
-      return dict.mapWithIndex;
-  }; 
-  var functorWithIndexArray = new FunctorWithIndex(function () {
-      return Data_Functor.functorArray;
-  }, $foreign.mapWithIndexArray);
-  exports["FunctorWithIndex"] = FunctorWithIndex;
-  exports["mapWithIndex"] = mapWithIndex;
-  exports["functorWithIndexArray"] = functorWithIndexArray;
-})(PS["Data.FunctorWithIndex"] = PS["Data.FunctorWithIndex"] || {});
+
+  exports.typeOf = function (value) {
+    return typeof value;
+  };
+
+  exports.tagOf = function (value) {
+    return Object.prototype.toString.call(value).slice(8, -1);
+  };
+
+  exports.isNull = function (value) {
+    return value === null;
+  };
+
+  exports.isUndefined = function (value) {
+    return value === undefined;
+  };
+
+  exports.isArray = Array.isArray || function (value) {
+    return Object.prototype.toString.call(value) === "[object Array]";
+  };
+})(PS["Foreign"] = PS["Foreign"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
+  var $foreign = PS["Foreign"];
   var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
-  var Control_Bind = PS["Control.Bind"];
+  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
+  var Control_Monad_Except = PS["Control.Monad.Except"];
+  var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Foldable = PS["Data.Foldable"];
+  var Data_Boolean = PS["Data.Boolean"];
+  var Data_Either = PS["Data.Either"];
+  var Data_Eq = PS["Data.Eq"];
   var Data_Function = PS["Data.Function"];
-  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Identity = PS["Data.Identity"];
+  var Data_Int = PS["Data.Int"];
+  var Data_List_NonEmpty = PS["Data.List.NonEmpty"];
   var Data_Maybe = PS["Data.Maybe"];
-  var Data_Maybe_First = PS["Data.Maybe.First"];
-  var Data_Maybe_Last = PS["Data.Maybe.Last"];
-  var Data_Monoid = PS["Data.Monoid"];
-  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
-  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
-  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
-  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
-  var Data_Monoid_Endo = PS["Data.Monoid.Endo"];
-  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
-  var Data_Newtype = PS["Data.Newtype"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ordering = PS["Data.Ordering"];
   var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];        
-  var Tuple = (function () {
-      function Tuple(value0, value1) {
+  var Data_Show = PS["Data.Show"];
+  var Data_String_CodeUnits = PS["Data.String.CodeUnits"];
+  var Prelude = PS["Prelude"];                 
+  var ForeignError = (function () {
+      function ForeignError(value0) {
+          this.value0 = value0;
+      };
+      ForeignError.create = function (value0) {
+          return new ForeignError(value0);
+      };
+      return ForeignError;
+  })();
+  var TypeMismatch = (function () {
+      function TypeMismatch(value0, value1) {
           this.value0 = value0;
           this.value1 = value1;
       };
-      Tuple.create = function (value0) {
+      TypeMismatch.create = function (value0) {
           return function (value1) {
-              return new Tuple(value0, value1);
+              return new TypeMismatch(value0, value1);
           };
       };
-      return Tuple;
+      return TypeMismatch;
   })();
-  var FoldableWithIndex = function (Foldable0, foldMapWithIndex, foldlWithIndex, foldrWithIndex) {
-      this.Foldable0 = Foldable0;
-      this.foldMapWithIndex = foldMapWithIndex;
-      this.foldlWithIndex = foldlWithIndex;
-      this.foldrWithIndex = foldrWithIndex;
-  };
-  var foldrWithIndex = function (dict) {
-      return dict.foldrWithIndex;
-  };
-  var traverseWithIndex_ = function (dictApplicative) {
-      return function (dictFoldableWithIndex) {
-          return function (f) {
-              return foldrWithIndex(dictFoldableWithIndex)(function (i) {
-                  return function ($41) {
-                      return Control_Apply.applySecond(dictApplicative.Apply0())(f(i)($41));
-                  };
-              })(Control_Applicative.pure(dictApplicative)(Data_Unit.unit));
+  var ErrorAtIndex = (function () {
+      function ErrorAtIndex(value0, value1) {
+          this.value0 = value0;
+          this.value1 = value1;
+      };
+      ErrorAtIndex.create = function (value0) {
+          return function (value1) {
+              return new ErrorAtIndex(value0, value1);
           };
       };
-  };
-  var forWithIndex_ = function (dictApplicative) {
-      return function (dictFoldableWithIndex) {
-          return Data_Function.flip(traverseWithIndex_(dictApplicative)(dictFoldableWithIndex));
+      return ErrorAtIndex;
+  })();
+  var ErrorAtProperty = (function () {
+      function ErrorAtProperty(value0, value1) {
+          this.value0 = value0;
+          this.value1 = value1;
+      };
+      ErrorAtProperty.create = function (value0) {
+          return function (value1) {
+              return new ErrorAtProperty(value0, value1);
+          };
+      };
+      return ErrorAtProperty;
+  })();
+  var renderForeignError = function (v) {
+      if (v instanceof ForeignError) {
+          return v.value0;
+      };
+      if (v instanceof ErrorAtIndex) {
+          return "Error at array index " + (Data_Show.show(Data_Show.showInt)(v.value0) + (": " + renderForeignError(v.value1)));
+      };
+      if (v instanceof ErrorAtProperty) {
+          return "Error at property " + (Data_Show.show(Data_Show.showString)(v.value0) + (": " + renderForeignError(v.value1)));
+      };
+      if (v instanceof TypeMismatch) {
+          return "Type mismatch: expected " + (v.value0 + (", found " + v.value1));
       };
+      throw new Error("Failed pattern match at Foreign line 72, column 1 - line 72, column 45: " + [ v.constructor.name ]);
   };
-  var foldlWithIndex = function (dict) {
-      return dict.foldlWithIndex;
+  var fail = function ($107) {
+      return Control_Monad_Error_Class.throwError(Control_Monad_Except_Trans.monadThrowExceptT(Data_Identity.monadIdentity))(Data_List_NonEmpty.singleton($107));
   };
-  var foldMapWithIndexDefaultR = function (dictFoldableWithIndex) {
-      return function (dictMonoid) {
-          return function (f) {
-              return foldrWithIndex(dictFoldableWithIndex)(function (i) {
-                  return function (x) {
-                      return function (acc) {
-                          return Data_Semigroup.append(dictMonoid.Semigroup0())(f(i)(x))(acc);
-                      };
-                  };
-              })(Data_Monoid.mempty(dictMonoid));
-          };
+  var readArray = function (value) {
+      if ($foreign.isArray(value)) {
+          return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))($foreign.unsafeFromForeign(value));
+      };
+      if (Data_Boolean.otherwise) {
+          return fail(new TypeMismatch("array", $foreign.tagOf(value)));
       };
+      throw new Error("Failed pattern match at Foreign line 147, column 1 - line 147, column 42: " + [ value.constructor.name ]);
   };
-  var foldableWithIndexArray = new FoldableWithIndex(function () {
-      return Data_Foldable.foldableArray;
-  }, function (dictMonoid) {
-      return foldMapWithIndexDefaultR(foldableWithIndexArray)(dictMonoid);
-  }, function (f) {
-      return function (z) {
-          return function ($42) {
-              return Data_Foldable.foldl(Data_Foldable.foldableArray)(function (y) {
-                  return function (v) {
-                      return f(v.value0)(y)(v.value1);
-                  };
-              })(z)(Data_FunctorWithIndex.mapWithIndex(Data_FunctorWithIndex.functorWithIndexArray)(Tuple.create)($42));
+  var unsafeReadTagged = function (tag) {
+      return function (value) {
+          if ($foreign.tagOf(value) === tag) {
+              return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))($foreign.unsafeFromForeign(value));
           };
-      };
-  }, function (f) {
-      return function (z) {
-          return function ($43) {
-              return Data_Foldable.foldr(Data_Foldable.foldableArray)(function (v) {
-                  return function (y) {
-                      return f(v.value0)(v.value1)(y);
-                  };
-              })(z)(Data_FunctorWithIndex.mapWithIndex(Data_FunctorWithIndex.functorWithIndexArray)(Tuple.create)($43));
+          if (Data_Boolean.otherwise) {
+              return fail(new TypeMismatch(tag, $foreign.tagOf(value)));
           };
+          throw new Error("Failed pattern match at Foreign line 106, column 1 - line 106, column 55: " + [ tag.constructor.name, value.constructor.name ]);
       };
-  });
-  var foldMapWithIndex = function (dict) {
-      return dict.foldMapWithIndex;
+  };                                            
+  var readNumber = unsafeReadTagged("Number");
+  var readInt = function (value) {
+      var error = Data_Either.Left.create(Data_List_NonEmpty.singleton(new TypeMismatch("Int", $foreign.tagOf(value))));
+      var fromNumber = function ($108) {
+          return Data_Maybe.maybe(error)(Control_Applicative.pure(Data_Either.applicativeEither))(Data_Int.fromNumber($108));
+      };
+      return Control_Monad_Except.mapExcept(Data_Either.either(Data_Function["const"](error))(fromNumber))(readNumber(value));
   };
-  exports["FoldableWithIndex"] = FoldableWithIndex;
-  exports["foldrWithIndex"] = foldrWithIndex;
-  exports["foldlWithIndex"] = foldlWithIndex;
-  exports["foldMapWithIndex"] = foldMapWithIndex;
-  exports["foldMapWithIndexDefaultR"] = foldMapWithIndexDefaultR;
-  exports["traverseWithIndex_"] = traverseWithIndex_;
-  exports["forWithIndex_"] = forWithIndex_;
-  exports["foldableWithIndexArray"] = foldableWithIndexArray;
-})(PS["Data.FoldableWithIndex"] = PS["Data.FoldableWithIndex"] || {});
+  var readString = unsafeReadTagged("String");
+  exports["ForeignError"] = ForeignError;
+  exports["TypeMismatch"] = TypeMismatch;
+  exports["ErrorAtIndex"] = ErrorAtIndex;
+  exports["ErrorAtProperty"] = ErrorAtProperty;
+  exports["renderForeignError"] = renderForeignError;
+  exports["unsafeReadTagged"] = unsafeReadTagged;
+  exports["readString"] = readString;
+  exports["readNumber"] = readNumber;
+  exports["readInt"] = readInt;
+  exports["readArray"] = readArray;
+  exports["fail"] = fail;
+  exports["typeOf"] = $foreign.typeOf;
+  exports["isNull"] = $foreign.isNull;
+  exports["isUndefined"] = $foreign.isUndefined;
+})(PS["Foreign"] = PS["Foreign"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.Foreign.NullOrUndefined"];
+  var $foreign = PS["Foreign.NullOrUndefined"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_Foreign = PS["Data.Foreign"];
   var Data_Functor = PS["Data.Functor"];
   var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
   var Data_Identity = PS["Data.Identity"];
   var Data_Maybe = PS["Data.Maybe"];
-  var Data_Newtype = PS["Data.Newtype"];
-  var Data_Ord = PS["Data.Ord"];
-  var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Show = PS["Data.Show"];
-  var Prelude = PS["Prelude"];        
-  var NullOrUndefined = function (x) {
-      return x;
-  };
+  var Foreign = PS["Foreign"];
+  var Prelude = PS["Prelude"];                 
   var readNullOrUndefined = function (v) {
       return function (value) {
-          if (Data_Foreign.isNull(value) || Data_Foreign.isUndefined(value)) {
+          if (Foreign.isNull(value) || Foreign.isUndefined(value)) {
               return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_Maybe.Nothing.value);
           };
-          return Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(function ($23) {
-              return NullOrUndefined(Data_Maybe.Just.create($23));
-          })(v(value));
+          return Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Maybe.Just.create)(v(value));
       };
   };
-  var newtypeNullOrUndefined = new Data_Newtype.Newtype(function (n) {
-      return n;
-  }, NullOrUndefined);
-  exports["NullOrUndefined"] = NullOrUndefined;
   exports["readNullOrUndefined"] = readNullOrUndefined;
-  exports["newtypeNullOrUndefined"] = newtypeNullOrUndefined;
-})(PS["Data.Foreign.NullOrUndefined"] = PS["Data.Foreign.NullOrUndefined"] || {});
+})(PS["Foreign.NullOrUndefined"] = PS["Foreign.NullOrUndefined"] || {});
 (function(exports) {
     "use strict";
 
-  exports._copyEff = function (m) {
+  exports._copyST = function (m) {
     return function () {
       var r = {};
       for (var k in m) {
@@ -3554,7 +4050,7 @@ var PS = {};
   };                 
 
   exports.runST = function (f) {
-    return f;
+    return f();
   };
 
   exports._foldM = function (bind) {
@@ -3593,7 +4089,7 @@ var PS = {};
       return r;
     };
   }
-})(PS["Data.StrMap"] = PS["Data.StrMap"] || {});
+})(PS["Foreign.Object"] = PS["Foreign.Object"] || {});
 (function(exports) {
     "use strict";
 
@@ -3601,9 +4097,9 @@ var PS = {};
     return {};
   };
 
-  exports.poke = function (m) {
-    return function (k) {
-      return function (v) {
+  exports.poke = function (k) {
+    return function (v) {
+      return function (m) {
         return function () {
           m[k] = v;
           return m;
@@ -3611,27 +4107,26 @@ var PS = {};
       };
     };
   };
-})(PS["Data.StrMap.ST"] = PS["Data.StrMap.ST"] || {});
+})(PS["Foreign.Object.ST"] = PS["Foreign.Object.ST"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.StrMap.ST"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
+  var $foreign = PS["Foreign.Object.ST"];
   var Control_Monad_ST = PS["Control.Monad.ST"];
   var Data_Maybe = PS["Data.Maybe"];
   exports["new"] = $foreign["new"];
   exports["poke"] = $foreign.poke;
-})(PS["Data.StrMap.ST"] = PS["Data.StrMap.ST"] || {});
+})(PS["Foreign.Object.ST"] = PS["Foreign.Object.ST"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.StrMap"];
+  var $foreign = PS["Foreign.Object"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
   var Control_Category = PS["Control.Category"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
   var Control_Monad_ST = PS["Control.Monad.ST"];
+  var Control_Monad_ST_Internal = PS["Control.Monad.ST.Internal"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
   var Data_Array = PS["Data.Array"];
   var Data_Eq = PS["Data.Eq"];
@@ -3647,27 +4142,21 @@ var PS = {};
   var Data_Ord = PS["Data.Ord"];
   var Data_Semigroup = PS["Data.Semigroup"];
   var Data_Show = PS["Data.Show"];
-  var Data_StrMap_ST = PS["Data.StrMap.ST"];
   var Data_Traversable = PS["Data.Traversable"];
   var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
   var Data_Tuple = PS["Data.Tuple"];
   var Data_Unfoldable = PS["Data.Unfoldable"];
+  var Foreign_Object_ST = PS["Foreign.Object.ST"];
   var Prelude = PS["Prelude"];                                   
-  var thawST = $foreign._copyEff;
-  var pureST = function (f) {
-      return Control_Monad_Eff.runPure($foreign.runST(f));
-  };
+  var thawST = $foreign._copyST;
   var singleton = function (k) {
       return function (v) {
-          return pureST(function __do() {
-              var v1 = Data_StrMap_ST["new"]();
-              return Data_StrMap_ST.poke(v1)(k)(v)();
-          });
+          return $foreign.runST(Control_Bind.bindFlipped(Control_Monad_ST_Internal.bindST)(Foreign_Object_ST.poke(k)(v))(Foreign_Object_ST["new"]));
       };
   };
   var mutate = function (f) {
       return function (m) {
-          return pureST(function __do() {
+          return $foreign.runST(function __do() {
               var v = thawST(m)();
               var v1 = f(v)();
               return v;
@@ -3677,10 +4166,10 @@ var PS = {};
   var lookup = Data_Function_Uncurried.runFn4($foreign._lookup)(Data_Maybe.Nothing.value)(Data_Maybe.Just.create);
   var fromFoldable = function (dictFoldable) {
       return function (l) {
-          return pureST(function __do() {
-              var v = Data_StrMap_ST["new"]();
-              Control_Monad_Eff.foreachE(Data_Array.fromFoldable(dictFoldable)(l))(function (v1) {
-                  return Data_Functor["void"](Control_Monad_Eff.functorEff)(Data_StrMap_ST.poke(v)(v1.value0)(v1.value1));
+          return $foreign.runST(function __do() {
+              var v = Foreign_Object_ST["new"]();
+              Data_Foldable.for_(Control_Monad_ST_Internal.applicativeST)(Data_Foldable.foldableArray)(Data_Array.fromFoldable(dictFoldable)(l))(function (v1) {
+                  return Foreign_Object_ST.poke(v1.value0)(v1.value1)(v);
               })();
               return v;
           });
@@ -3693,26 +4182,32 @@ var PS = {};
           };
       };
   };
-  var semigroupStrMap = function (dictSemigroup) {
+  var semigroupObject = function (dictSemigroup) {
       return new Data_Semigroup.Semigroup(function (m1) {
           return function (m2) {
               return mutate(function (s1) {
-                  return Data_Functor["void"](Control_Monad_Eff.functorEff)(foldM(Control_Monad_Eff.monadEff)(function (s2) {
+                  return foldM(Control_Monad_ST_Internal.monadST)(function (s2) {
                       return function (k) {
                           return function (v2) {
-                              return Data_StrMap_ST.poke(s2)(k)($foreign._lookup(v2, function (v1) {
+                              return Foreign_Object_ST.poke(k)($foreign._lookup(v2, function (v1) {
                                   return Data_Semigroup.append(dictSemigroup)(v1)(v2);
-                              }, k, m2));
+                              }, k, m2))(s2);
                           };
                       };
-                  })(s1)(m1));
+                  })(s1)(m1);
               })(m2);
           };
       });
   };
   var union = function (m) {
       return mutate(function (s) {
-          return Data_Functor["void"](Control_Monad_Eff.functorEff)(foldM(Control_Monad_Eff.monadEff)(Data_StrMap_ST.poke)(s)(m));
+          return foldM(Control_Monad_ST_Internal.monadST)(function (s$prime) {
+              return function (k) {
+                  return function (v) {
+                      return Foreign_Object_ST.poke(k)(v)(s$prime);
+                  };
+              };
+          })(s)(m);
       });
   };
   exports["singleton"] = singleton;
@@ -3721,11 +4216,10 @@ var PS = {};
   exports["union"] = union;
   exports["foldM"] = foldM;
   exports["thawST"] = thawST;
-  exports["pureST"] = pureST;
-  exports["semigroupStrMap"] = semigroupStrMap;
-})(PS["Data.StrMap"] = PS["Data.StrMap"] || {});
+  exports["semigroupObject"] = semigroupObject;
+})(PS["Foreign.Object"] = PS["Foreign.Object"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Bind = PS["Control.Bind"];
@@ -3736,38 +4230,40 @@ var PS = {};
   var Data_Array = PS["Data.Array"];
   var Data_Bifunctor = PS["Data.Bifunctor"];
   var Data_Either = PS["Data.Either"];
-  var Data_Foreign = PS["Data.Foreign"];
-  var Data_Foreign_Internal = PS["Data.Foreign.Internal"];
-  var Data_Foreign_NullOrUndefined = PS["Data.Foreign.NullOrUndefined"];
   var Data_Functor = PS["Data.Functor"];
   var Data_Identity = PS["Data.Identity"];
   var Data_List_Types = PS["Data.List.Types"];
   var Data_Maybe = PS["Data.Maybe"];
-  var Data_StrMap = PS["Data.StrMap"];
   var Data_Traversable = PS["Data.Traversable"];
-  var Prelude = PS["Prelude"];        
+  var Data_Unit = PS["Data.Unit"];
+  var Data_Void = PS["Data.Void"];
+  var Foreign = PS["Foreign"];
+  var Foreign_Internal = PS["Foreign.Internal"];
+  var Foreign_NullOrUndefined = PS["Foreign.NullOrUndefined"];
+  var Foreign_Object = PS["Foreign.Object"];
+  var Prelude = PS["Prelude"];                 
   var Decode = function (decode) {
       this.decode = decode;
-  };                                                    
-  var stringDecode = new Decode(Data_Foreign.readString);
-  var intDecode = new Decode(Data_Foreign.readInt);
+  };                                                     
+  var stringDecode = new Decode(Foreign.readString);  
+  var intDecode = new Decode(Foreign.readInt);
   var decode = function (dict) {
       return dict.decode;
   };
-  var decodeNullOrUndefined = function (dictDecode) {
-      return new Decode(Data_Foreign_NullOrUndefined.readNullOrUndefined(decode(dictDecode)));
+  var maybeDecode = function (dictDecode) {
+      return new Decode(Foreign_NullOrUndefined.readNullOrUndefined(decode(dictDecode)));
   };
   var arrayDecode = function (dictDecode) {
       return new Decode((function () {
           var readElement = function (i) {
               return function (value) {
-                  return Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Data_Foreign.ErrorAtIndex.create(i))))(decode(dictDecode)(value));
+                  return Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Foreign.ErrorAtIndex.create(i))))(decode(dictDecode)(value));
               };
           };
           var readElements = function (arr) {
               return Data_Traversable.sequence(Data_Traversable.traversableArray)(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_Array.zipWith(readElement)(Data_Array.range(0)(Data_Array.length(arr)))(arr));
           };
-          return Control_Bind.composeKleisli(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Data_Foreign.readArray)(readElements);
+          return Control_Bind.composeKleisli(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Foreign.readArray)(readElements);
       })());
   };
   exports["decode"] = decode;
@@ -3775,10 +4271,10 @@ var PS = {};
   exports["stringDecode"] = stringDecode;
   exports["intDecode"] = intDecode;
   exports["arrayDecode"] = arrayDecode;
-  exports["decodeNullOrUndefined"] = decodeNullOrUndefined;
-})(PS["Data.Foreign.Class"] = PS["Data.Foreign.Class"] || {});
+  exports["maybeDecode"] = maybeDecode;
+})(PS["Foreign.Class"] = PS["Foreign.Class"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var TaggedObject = (function () {
       function TaggedObject(value0) {
@@ -3790,7 +4286,7 @@ var PS = {};
       return TaggedObject;
   })();
   exports["TaggedObject"] = TaggedObject;
-})(PS["Data.Foreign.Generic.Types"] = PS["Data.Foreign.Generic.Types"] || {});
+})(PS["Foreign.Generic.Types"] = PS["Foreign.Generic.Types"] || {});
 (function(exports) {
     "use strict";
 
@@ -3805,22 +4301,22 @@ var PS = {};
   exports.unsafeHasProperty = function (prop, value) {
     return prop in value;
   };
-})(PS["Data.Foreign.Index"] = PS["Data.Foreign.Index"] || {});
+})(PS["Foreign.Index"] = PS["Foreign.Index"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.Foreign.Index"];
+  var $foreign = PS["Foreign.Index"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Bind = PS["Control.Bind"];
   var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
   var Data_Eq = PS["Data.Eq"];
-  var Data_Foreign = PS["Data.Foreign"];
   var Data_Function = PS["Data.Function"];
   var Data_Function_Uncurried = PS["Data.Function.Uncurried"];
   var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
   var Data_Identity = PS["Data.Identity"];
   var Data_List_NonEmpty = PS["Data.List.NonEmpty"];
-  var Prelude = PS["Prelude"];        
+  var Foreign = PS["Foreign"];
+  var Prelude = PS["Prelude"];                 
   var Index = function (errorAt, hasOwnProperty, hasProperty, index) {
       this.errorAt = errorAt;
       this.hasOwnProperty = hasOwnProperty;
@@ -3829,7 +4325,7 @@ var PS = {};
   };
   var unsafeReadProp = function (k) {
       return function (value) {
-          return $foreign.unsafeReadPropImpl(Data_Foreign.fail(new Data_Foreign.TypeMismatch("object", Data_Foreign.typeOf(value))), Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity)), k, value);
+          return $foreign.unsafeReadPropImpl(Foreign.fail(new Foreign.TypeMismatch("object", Foreign.typeOf(value))), Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity)), k, value);
       };
   };
   var readProp = unsafeReadProp;
@@ -3838,13 +4334,13 @@ var PS = {};
   }; 
   var hasPropertyImpl = function (v) {
       return function (value) {
-          if (Data_Foreign.isNull(value)) {
+          if (Foreign.isNull(value)) {
               return false;
           };
-          if (Data_Foreign.isUndefined(value)) {
+          if (Foreign.isUndefined(value)) {
               return false;
           };
-          if (Data_Foreign.typeOf(value) === "object" || Data_Foreign.typeOf(value) === "function") {
+          if (Foreign.typeOf(value) === "object" || Foreign.typeOf(value) === "function") {
               return $foreign.unsafeHasProperty(v, value);
           };
           return false;
@@ -3855,19 +4351,19 @@ var PS = {};
   };
   var hasOwnPropertyImpl = function (v) {
       return function (value) {
-          if (Data_Foreign.isNull(value)) {
+          if (Foreign.isNull(value)) {
               return false;
           };
-          if (Data_Foreign.isUndefined(value)) {
+          if (Foreign.isUndefined(value)) {
               return false;
           };
-          if (Data_Foreign.typeOf(value) === "object" || Data_Foreign.typeOf(value) === "function") {
+          if (Foreign.typeOf(value) === "object" || Foreign.typeOf(value) === "function") {
               return $foreign.unsafeHasOwnProperty(v, value);
           };
           return false;
       };
-  };                                                                                                                             
-  var indexString = new Index(Data_Foreign.ErrorAtProperty.create, hasOwnPropertyImpl, hasPropertyImpl, Data_Function.flip(readProp));
+  };                                                                                                                        
+  var indexString = new Index(Foreign.ErrorAtProperty.create, hasOwnPropertyImpl, hasPropertyImpl, Data_Function.flip(readProp));
   var hasOwnProperty = function (dict) {
       return dict.hasOwnProperty;
   };
@@ -3881,91 +4377,68 @@ var PS = {};
   exports["hasOwnProperty"] = hasOwnProperty;
   exports["errorAt"] = errorAt;
   exports["indexString"] = indexString;
-})(PS["Data.Foreign.Index"] = PS["Data.Foreign.Index"] || {});
+})(PS["Foreign.Index"] = PS["Foreign.Index"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Data_Maybe = PS["Data.Maybe"];        
-  var Inl = (function () {
-      function Inl(value0) {
-          this.value0 = value0;
-      };
-      Inl.create = function (value0) {
-          return new Inl(value0);
-      };
-      return Inl;
-  })();
-  var Inr = (function () {
-      function Inr(value0) {
-          this.value0 = value0;
-      };
-      Inr.create = function (value0) {
-          return new Inr(value0);
-      };
-      return Inr;
-  })();
-  var Product = (function () {
-      function Product(value0, value1) {
-          this.value0 = value0;
-          this.value1 = value1;
-      };
-      Product.create = function (value0) {
-          return function (value1) {
-              return new Product(value0, value1);
-          };
-      };
-      return Product;
-  })();
-  var Field = function (x) {
-      return x;
-  };
-  var Constructor = function (x) {
-      return x;
-  };
-  var Generic = function (from, to) {
-      this.from = from;
-      this.to = to;
+    "use strict";
+
+  exports.copyRecord = function(rec) {
+    var copy = {};
+    for (var key in rec) {
+      if ({}.hasOwnProperty.call(rec, key)) {
+        copy[key] = rec[key];
+      }
+    }
+    return copy;
   };
-  var to = function (dict) {
-      return dict.to;
-  }; 
-  var from = function (dict) {
-      return dict.from;
+
+  exports.unsafeInsert = function(l) {
+    return function(a) {
+      return function(rec) {
+        rec[l] = a;
+        return rec;
+      };
+    };
   };
-  exports["Generic"] = Generic;
-  exports["to"] = to;
-  exports["from"] = from;
-  exports["Inl"] = Inl;
-  exports["Inr"] = Inr;
-  exports["Product"] = Product;
-  exports["Constructor"] = Constructor;
-  exports["Field"] = Field;
-})(PS["Data.Generic.Rep"] = PS["Data.Generic.Rep"] || {});
+})(PS["Record.Builder"] = PS["Record.Builder"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Data_Semigroup = PS["Data.Semigroup"];
+  var $foreign = PS["Record.Builder"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Function_Uncurried = PS["Data.Function.Uncurried"];
+  var Data_Symbol = PS["Data.Symbol"];
   var Prelude = PS["Prelude"];
-  var Unsafe_Coerce = PS["Unsafe.Coerce"];        
-  var SProxy = (function () {
-      function SProxy() {
-
+  var Record_Unsafe_Union = PS["Record.Unsafe.Union"];
+  var Type_Row = PS["Type.Row"];
+  var Unsafe_Coerce = PS["Unsafe.Coerce"];
+  var semigroupoidBuilder = Control_Semigroupoid.semigroupoidFn;
+  var insert = function (dictCons) {
+      return function (dictLacks) {
+          return function (dictIsSymbol) {
+              return function (l) {
+                  return function (a) {
+                      return function (r1) {
+                          return $foreign.unsafeInsert(Data_Symbol.reflectSymbol(dictIsSymbol)(l))(a)(r1);
+                      };
+                  };
+              };
+          };
       };
-      SProxy.value = new SProxy();
-      return SProxy;
-  })();
-  var IsSymbol = function (reflectSymbol) {
-      this.reflectSymbol = reflectSymbol;
   };
-  var reflectSymbol = function (dict) {
-      return dict.reflectSymbol;
+  var categoryBuilder = Control_Category.categoryFn;
+  var build = function (v) {
+      return function (r1) {
+          return v($foreign.copyRecord(r1));
+      };
   };
-  exports["IsSymbol"] = IsSymbol;
-  exports["reflectSymbol"] = reflectSymbol;
-  exports["SProxy"] = SProxy;
-})(PS["Data.Symbol"] = PS["Data.Symbol"] || {});
+  exports["build"] = build;
+  exports["insert"] = insert;
+  exports["semigroupoidBuilder"] = semigroupoidBuilder;
+  exports["categoryBuilder"] = categoryBuilder;
+})(PS["Record.Builder"] = PS["Record.Builder"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Apply = PS["Control.Apply"];
@@ -3994,12 +4467,12 @@ var PS = {};
   exports["Proxy"] = $$Proxy;
 })(PS["Type.Proxy"] = PS["Type.Proxy"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Alt = PS["Control.Alt"];
   var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
+  var Control_Category = PS["Control.Category"];
   var Control_Monad_Except = PS["Control.Monad.Except"];
   var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
@@ -4007,10 +4480,6 @@ var PS = {};
   var Data_Either = PS["Data.Either"];
   var Data_Eq = PS["Data.Eq"];
   var Data_Foldable = PS["Data.Foldable"];
-  var Data_Foreign = PS["Data.Foreign"];
-  var Data_Foreign_Class = PS["Data.Foreign.Class"];
-  var Data_Foreign_Generic_Types = PS["Data.Foreign.Generic.Types"];
-  var Data_Foreign_Index = PS["Data.Foreign.Index"];
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
   var Data_Generic_Rep = PS["Data.Generic.Rep"];
@@ -4022,41 +4491,51 @@ var PS = {};
   var Data_Semigroup = PS["Data.Semigroup"];
   var Data_Semiring = PS["Data.Semiring"];
   var Data_Show = PS["Data.Show"];
-  var Data_StrMap = PS["Data.StrMap"];
   var Data_Symbol = PS["Data.Symbol"];
   var Data_Unfoldable = PS["Data.Unfoldable"];
+  var Foreign = PS["Foreign"];
+  var Foreign_Class = PS["Foreign.Class"];
+  var Foreign_Generic_Types = PS["Foreign.Generic.Types"];
+  var Foreign_Index = PS["Foreign.Index"];
+  var Foreign_Object = PS["Foreign.Object"];
   var Prelude = PS["Prelude"];
-  var Type_Proxy = PS["Type.Proxy"];        
+  var Record = PS["Record"];
+  var Record_Builder = PS["Record.Builder"];
+  var Type_Data_RowList = PS["Type.Data.RowList"];
+  var Type_Proxy = PS["Type.Proxy"];
+  var Unsafe_Coerce = PS["Unsafe.Coerce"];                 
   var GenericDecode = function (decodeOpts) {
       this.decodeOpts = decodeOpts;
   };
   var GenericDecodeArgs = function (decodeArgs) {
       this.decodeArgs = decodeArgs;
   };
-  var GenericDecodeFields = function (decodeFields) {
-      this.decodeFields = decodeFields;
-  };
   var GenericCountArgs = function (countArgs) {
       this.countArgs = countArgs;
+  };
+  var Decode_ = function (decode_) {
+      this.decode_ = decode_;
+  };
+  var DecodeRecord = function (decodeRecord_) {
+      this.decodeRecord_ = decodeRecord_;
   }; 
-  var genericDecodeFieldsField = function (dictIsSymbol) {
-      return function (dictDecode) {
-          return new GenericDecodeFields(function (opts) {
-              return function (x) {
-                  var name = opts.fieldTransform(Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value));
-                  return Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Generic_Rep.Field)(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Data_Foreign_Index.index(Data_Foreign_Index.indexString)(x)(name))(function ($158) {
-                      return Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Data_Foreign.ErrorAtProperty.create(name))))(Data_Foreign_Class.decode(dictDecode)($158));
-                  }));
-              };
-          });
-      };
-  }; 
-  var genericDecodeArgsArgument = function (dictDecode) {
+  var genericCountArgsArgument = new GenericCountArgs(function (v) {
+      return new Data_Either.Right(1);
+  });
+  var decode_Other = function (dictDecode) {
+      return new Decode_(function (v) {
+          return Foreign_Class.decode(dictDecode);
+      });
+  };
+  var decode_ = function (dict) {
+      return dict.decode_;
+  };
+  var genericDecodeArgsArgument = function (dictDecode_) {
       return new GenericDecodeArgs(function (v) {
           return function (v1) {
               return function (v2) {
                   if (v2 instanceof Data_List_Types.Cons) {
-                      return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Data_Foreign.ErrorAtIndex.create(v1))))(Data_Foreign_Class.decode(dictDecode)(v2.value0)))(function (v3) {
+                      return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Foreign.ErrorAtIndex.create(v1))))(decode_(dictDecode_)(v)(v2.value0)))(function (v3) {
                           return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))({
                               result: v3,
                               rest: v2.value1,
@@ -4064,65 +4543,67 @@ var PS = {};
                           });
                       });
                   };
-                  return Data_Foreign.fail(new Data_Foreign.ForeignError("Not enough constructor arguments"));
+                  return Foreign.fail(new Foreign.ForeignError("Not enough constructor arguments"));
               };
           };
       });
   };
-  var genericCountArgsRec = new GenericCountArgs(function (v) {
-      return new Data_Either.Right(1);
-  });
-  var genericCountArgsArgument = new GenericCountArgs(function (v) {
-      return new Data_Either.Right(1);
-  });
-  var decodeOpts = function (dict) {
-      return dict.decodeOpts;
+  var decodeRecord_ = function (dict) {
+      return dict.decodeRecord_;
   };
-  var genericDecodeSum = function (dictGenericDecode) {
-      return function (dictGenericDecode1) {
-          return new GenericDecode(function (opts) {
-              return function (f) {
-                  var opts$prime = (function () {
-                      var $111 = {};
-                      for (var $112 in opts) {
-                          if ({}.hasOwnProperty.call(opts, $112)) {
-                              $111[$112] = opts[$112];
-                          };
-                      };
-                      $111.unwrapSingleConstructors = false;
-                      return $111;
-                  })();
-                  return Control_Alt.alt(Control_Monad_Except_Trans.altExceptT(Data_List_Types.semigroupNonEmptyList)(Data_Identity.monadIdentity))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Generic_Rep.Inl.create)(decodeOpts(dictGenericDecode)(opts$prime)(f)))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Generic_Rep.Inr.create)(decodeOpts(dictGenericDecode1)(opts$prime)(f)));
-              };
+  var decode_Record = function (dictRowToList) {
+      return function (dictDecodeRecord) {
+          return new Decode_(function (opts) {
+              return Data_Functor.map(Data_Functor.functorFn)(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Function.flip(Record_Builder.build)({})))(decodeRecord_(dictDecodeRecord)(Type_Data_RowList.RLProxy.value)(opts));
           });
       };
   };
-  var decodeFields = function (dict) {
-      return dict.decodeFields;
-  };
-  var genericDecodeArgsRec = function (dictGenericDecodeFields) {
-      return new GenericDecodeArgs(function (v) {
-          return function (v1) {
-              return function (v2) {
-                  if (v2 instanceof Data_List_Types.Cons) {
-                      return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Data_Foreign.ErrorAtIndex.create(v1))))(decodeFields(dictGenericDecodeFields)(v)(v2.value0)))(function (v3) {
-                          return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))({
-                              result: v3,
-                              rest: v2.value1,
-                              next: v1 + 1 | 0
-                          });
+  var decodeRecordNil = new DecodeRecord(function (v) {
+      return function (v1) {
+          return function (v2) {
+              return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Control_Category.identity(Record_Builder.categoryBuilder));
+          };
+      };
+  });
+  var decodeRecordCons = function (dictCons) {
+      return function (dictDecodeRecord) {
+          return function (dictIsSymbol) {
+              return function (dictDecode_) {
+                  return function (dictLacks) {
+                      return new DecodeRecord(function (v) {
+                          return function (opts) {
+                              return function (f) {
+                                  return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(decodeRecord_(dictDecodeRecord)(Type_Data_RowList.RLProxy.value)(opts)(f))(function (v1) {
+                                      var l = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
+                                      var l_transformed = opts.fieldTransform(l);
+                                      return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Foreign_Index.index(Foreign_Index.indexString)(f)(l_transformed))(function (v2) {
+                                          return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Foreign.ErrorAtProperty.create(l_transformed))))(decode_(dictDecode_)(opts)(v2)))(function (v3) {
+                                              return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Control_Semigroupoid.composeFlipped(Record_Builder.semigroupoidBuilder)(v1)(Record_Builder.insert(dictCons)(dictLacks)(dictIsSymbol)(Data_Symbol.SProxy.value)(v3)));
+                                          });
+                                      });
+                                  });
+                              };
+                          };
                       });
                   };
-                  return Data_Foreign.fail(new Data_Foreign.ForeignError("Not enough constructor arguments"));
               };
           };
-      });
+      };
   };
-  var genericDecodeFieldsProduct = function (dictGenericDecodeFields) {
-      return function (dictGenericDecodeFields1) {
-          return new GenericDecodeFields(function (opts) {
-              return function (x) {
-                  return Control_Apply.apply(Control_Monad_Except_Trans.applyExceptT(Data_Identity.monadIdentity))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Generic_Rep.Product.create)(decodeFields(dictGenericDecodeFields)(opts)(x)))(decodeFields(dictGenericDecodeFields1)(opts)(x));
+  var decodeOpts = function (dict) {
+      return dict.decodeOpts;
+  };
+  var genericDecodeSum = function (dictGenericDecode) {
+      return function (dictGenericDecode1) {
+          return new GenericDecode(function (opts) {
+              return function (f) {
+                  var opts$prime = {
+                      unwrapSingleConstructors: false,
+                      fieldTransform: opts.fieldTransform,
+                      sumEncoding: opts.sumEncoding,
+                      unwrapSingleArguments: opts.unwrapSingleArguments
+                  };
+                  return Control_Alt.alt(Control_Monad_Except_Trans.altExceptT(Data_List_Types.semigroupNonEmptyList)(Data_Identity.monadIdentity))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Generic_Rep.Inl.create)(decodeOpts(dictGenericDecode)(opts$prime)(f)))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Generic_Rep.Inr.create)(decodeOpts(dictGenericDecode1)(opts$prime)(f)));
               };
           });
       };
@@ -4145,33 +4626,33 @@ var PS = {};
                           };
                           if (numArgs instanceof Data_Either.Right && (numArgs.value0 === 1 && opts.unwrapSingleArguments)) {
                               return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(decodeArgs(dictGenericDecodeArgs)(opts)(0)(Data_List.singleton(args)))(function (v) {
-                                  return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Applicative.unless(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_List["null"](v.rest))(Data_Foreign.fail(new Data_Foreign.ForeignError("Expected a single argument"))))(function () {
+                                  return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Applicative.unless(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_List["null"](v.rest))(Foreign.fail(new Foreign.ForeignError("Expected a single argument"))))(function () {
                                       return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(v.result);
                                   });
                               });
                           };
                           if (numArgs instanceof Data_Either.Right) {
-                              return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Data_Foreign.readArray(args))(function (v) {
+                              return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Foreign.readArray(args))(function (v) {
                                   return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(decodeArgs(dictGenericDecodeArgs)(opts)(0)(Data_List.fromFoldable(Data_Foldable.foldableArray)(v)))(function (v1) {
-                                      return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Applicative.unless(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_List["null"](v1.rest))(Data_Foreign.fail(new Data_Foreign.ForeignError("Expected " + (Data_Show.show(Data_Show.showInt)(numArgs.value0) + " constructor arguments")))))(function () {
+                                      return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Applicative.unless(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_List["null"](v1.rest))(Foreign.fail(new Foreign.ForeignError("Expected " + (Data_Show.show(Data_Show.showInt)(numArgs.value0) + " constructor arguments")))))(function () {
                                           return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(v1.result);
                                       });
                                   });
                               });
                           };
-                          throw new Error("Failed pattern match at Data.Foreign.Generic.Class line 74, column 9 - line 86, column 24: " + [ numArgs.constructor.name ]);
+                          throw new Error("Failed pattern match at Foreign.Generic.Class line 75, column 9 - line 87, column 24: " + [ numArgs.constructor.name ]);
                       };
                       var ctorName = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
                       if (opts.unwrapSingleConstructors) {
                           return Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Generic_Rep.Constructor)(readArguments(f));
                       };
-                      return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Data_Foreign.ErrorAtProperty.create(opts.sumEncoding.value0.contentsFieldName))))(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Data_Foreign_Index.index(Data_Foreign_Index.indexString)(f)(opts.sumEncoding.value0.tagFieldName))(Data_Foreign.readString))(function (v) {
+                      return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Foreign.ErrorAtProperty.create(opts.sumEncoding.value0.tagFieldName))))(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Foreign_Index.index(Foreign_Index.indexString)(f)(opts.sumEncoding.value0.tagFieldName))(Foreign.readString))(function (v) {
                           var expected = opts.sumEncoding.value0.constructorTagTransform(ctorName);
-                          return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Applicative.unless(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(opts.sumEncoding.value0.constructorTagTransform(v) === expected)(Data_Foreign.fail(new Data_Foreign.ForeignError("Expected " + (Data_Show.show(Data_Show.showString)(expected) + " tag")))))(function () {
+                          return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Applicative.unless(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(v === expected)(Foreign.fail(new Foreign.ForeignError("Expected " + (Data_Show.show(Data_Show.showString)(expected) + " tag")))))(function () {
                               return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(v);
                           });
                       })))(function (v) {
-                          return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Data_Foreign.ErrorAtProperty.create(opts.sumEncoding.value0.contentsFieldName))))(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Data_Foreign_Index.index(Data_Foreign_Index.indexString)(f)(opts.sumEncoding.value0.contentsFieldName))(readArguments)))(function (v1) {
+                          return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Foreign.ErrorAtProperty.create(opts.sumEncoding.value0.contentsFieldName))))(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Foreign_Index.index(Foreign_Index.indexString)(f)(opts.sumEncoding.value0.contentsFieldName))(readArguments)))(function (v1) {
                               return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(v1);
                           });
                       });
@@ -4182,192 +4663,281 @@ var PS = {};
   };
   exports["countArgs"] = countArgs;
   exports["decodeArgs"] = decodeArgs;
-  exports["decodeFields"] = decodeFields;
   exports["decodeOpts"] = decodeOpts;
+  exports["decodeRecord_"] = decodeRecord_;
+  exports["decode_"] = decode_;
   exports["GenericDecode"] = GenericDecode;
   exports["GenericDecodeArgs"] = GenericDecodeArgs;
-  exports["GenericDecodeFields"] = GenericDecodeFields;
   exports["GenericCountArgs"] = GenericCountArgs;
+  exports["Decode_"] = Decode_;
+  exports["DecodeRecord"] = DecodeRecord;
   exports["genericDecodeConstructor"] = genericDecodeConstructor;
   exports["genericDecodeSum"] = genericDecodeSum;
   exports["genericDecodeArgsArgument"] = genericDecodeArgsArgument;
-  exports["genericDecodeArgsRec"] = genericDecodeArgsRec;
-  exports["genericDecodeFieldsField"] = genericDecodeFieldsField;
-  exports["genericDecodeFieldsProduct"] = genericDecodeFieldsProduct;
   exports["genericCountArgsArgument"] = genericCountArgsArgument;
-  exports["genericCountArgsRec"] = genericCountArgsRec;
-})(PS["Data.Foreign.Generic.Class"] = PS["Data.Foreign.Generic.Class"] || {});
+  exports["decode_Record"] = decode_Record;
+  exports["decode_Other"] = decode_Other;
+  exports["decodeRecordNil"] = decodeRecordNil;
+  exports["decodeRecordCons"] = decodeRecordCons;
+})(PS["Foreign.Generic.Class"] = PS["Foreign.Generic.Class"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  /* globals exports, JSON */
+  "use strict";                       
+  exports.unsafeDecodeURIComponent = decodeURIComponent;
+})(PS["Global.Unsafe"] = PS["Global.Unsafe"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Global.Unsafe"];
+  exports["unsafeDecodeURIComponent"] = $foreign.unsafeDecodeURIComponent;
+})(PS["Global.Unsafe"] = PS["Global.Unsafe"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Bind = PS["Control.Bind"];
   var Control_Category = PS["Control.Category"];
   var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Foreign = PS["Data.Foreign"];
-  var Data_Foreign_Class = PS["Data.Foreign.Class"];
-  var Data_Foreign_Generic_Class = PS["Data.Foreign.Generic.Class"];
-  var Data_Foreign_Generic_Types = PS["Data.Foreign.Generic.Types"];
-  var Data_Foreign_JSON = PS["Data.Foreign.JSON"];
   var Data_Functor = PS["Data.Functor"];
   var Data_Generic_Rep = PS["Data.Generic.Rep"];
   var Data_Identity = PS["Data.Identity"];
+  var Foreign = PS["Foreign"];
+  var Foreign_Class = PS["Foreign.Class"];
+  var Foreign_Generic_Class = PS["Foreign.Generic.Class"];
+  var Foreign_Generic_Types = PS["Foreign.Generic.Types"];
+  var Foreign_JSON = PS["Foreign.JSON"];
   var Global_Unsafe = PS["Global.Unsafe"];
   var Prelude = PS["Prelude"];
   var genericDecode = function (dictGeneric) {
       return function (dictGenericDecode) {
           return function (opts) {
               return function ($12) {
-                  return Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Generic_Rep.to(dictGeneric))(Data_Foreign_Generic_Class.decodeOpts(dictGenericDecode)(opts)($12));
+                  return Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Generic_Rep.to(dictGeneric))(Foreign_Generic_Class.decodeOpts(dictGenericDecode)(opts)($12));
               };
           };
       };
   };
   var defaultOptions = {
-      sumEncoding: new Data_Foreign_Generic_Types.TaggedObject({
+      sumEncoding: new Foreign_Generic_Types.TaggedObject({
           tagFieldName: "tag",
           contentsFieldName: "contents",
-          constructorTagTransform: Control_Category.id(Control_Category.categoryFn)
+          constructorTagTransform: Control_Category.identity(Control_Category.categoryFn)
       }),
       unwrapSingleConstructors: false,
       unwrapSingleArguments: true,
-      fieldTransform: Control_Category.id(Control_Category.categoryFn)
+      fieldTransform: Control_Category.identity(Control_Category.categoryFn)
   };
   exports["defaultOptions"] = defaultOptions;
   exports["genericDecode"] = genericDecode;
-})(PS["Data.Foreign.Generic"] = PS["Data.Foreign.Generic"] || {});
+})(PS["Foreign.Generic"] = PS["Foreign.Generic"] || {});
+(function(exports) {
+  /* global exports */
+  "use strict";
+
+  exports.ready = function(func) {
+      return function() {
+          jQuery(document).ready(func);
+      };
+  };
+
+  exports.select = function(selector) {
+      return function() {
+          return jQuery(selector);
+      };
+  };
+
+  exports.create = function(html) {
+      return function() {
+          return jQuery(html);
+      };
+  };
+
+  exports.setAttr = function(attr) {
+      return function(val) {
+          return function(ob) {
+              return function() {
+                  ob.attr(attr, val);
+              };
+          };
+      };
+  };
+
+  exports.attr = function(attrs) {
+      return function(ob) {
+          return function() {
+              ob.attr(attrs);
+          };
+      };
+  };
+
+  exports.toggleClass = function(cls) {
+      return function(ob) {
+          return function() {
+              ob.toggleClass(cls);
+          };
+      };
+  };
+
+  exports.setClass = function(cls) {
+      return function(flag) {
+          return function(ob) {
+              return function() {
+                  ob.toggleClass(cls, flag);
+              };
+          };
+      };
+  };
+
+  exports.setProp = function(p) {
+      return function(val) {
+          return function(ob) {
+              return function() {
+                  ob.prop(p, val);
+              };
+          };
+      };
+  };
+
+  exports.append = function(ob1) {
+      return function(ob) {
+          return function() {
+              ob.append(ob1);
+          };
+      };
+  };
+
+  exports.setText = function(text) {
+      return function(ob) {
+          return function() {
+              ob.text(text);
+          };
+      };
+  };
+
+  exports.setValue = function(val) {
+      return function(ob) {
+          return function() {
+              ob.val(val);
+          };
+      };
+  };
+
+  exports.toggle = function(ob) {
+      return function() {
+          ob.toggle();
+      };
+  };
+
+  exports.setVisible = function(flag) {
+      return function(ob) {
+          return function() {
+              ob.toggle(flag);
+          };
+      };
+  };
+
+  exports.on = function(evt) {
+      return function(act) {
+          return function(ob) {
+              return function() {
+                  ob.on(evt, function(e) {
+                      act(e)(jQuery(this))();
+                  });
+              };
+          };
+      };
+  };
+})(PS["JQuery"] = PS["JQuery"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["JQuery"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Effect = PS["Effect"];
+  var Foreign = PS["Foreign"];
+  var Prelude = PS["Prelude"];
+  var hide = $foreign.setVisible(false);  
+  var addClass = function (cls) {
+      return $foreign.setClass(cls)(true);
+  };
+  exports["addClass"] = addClass;
+  exports["hide"] = hide;
+  exports["ready"] = $foreign.ready;
+  exports["select"] = $foreign.select;
+  exports["create"] = $foreign.create;
+  exports["setAttr"] = $foreign.setAttr;
+  exports["attr"] = $foreign.attr;
+  exports["setProp"] = $foreign.setProp;
+  exports["append"] = $foreign.append;
+  exports["setText"] = $foreign.setText;
+  exports["setValue"] = $foreign.setValue;
+  exports["on"] = $foreign.on;
+})(PS["JQuery"] = PS["JQuery"] || {});
 (function(exports) {
     "use strict";
 
-  exports["regex'"] = function (left) {
-    return function (right) {
-      return function (s1) {
-        return function (s2) {
-          try {
-            return right(new RegExp(s1, s2));
-          } catch (e) {
-            return left(e.message);
-          }
-        };
+  exports.empty = function(jq) {
+    return function() {
+      jq.empty();
+    };
+  };
+
+  exports.fadeIn = function(jq) {
+    return function() {
+      jq.fadeIn();
+    };
+  };
+
+  exports.fadeOut = function(jq) {
+    return function() {
+      jq.fadeOut();
+    };
+  };
+
+  exports.filter = function(jq) {
+    return function(sel) {
+      return function() {
+        return jq.filter(sel);
       };
     };
   };
 
-  exports.replace = function (r) {
-    return function (s1) {
-      return function (s2) {
-        return s2.replace(r, s1);
+  exports.is = function(jq) {
+    return function(sel) {
+      return function() {
+        return jq.is(sel);
       };
     };
   };
 
-  exports["replace'"] = function (r) {
-    return function (f) {
-      return function (s2) {
-        return s2.replace(r, function (match) {
-          return f(match)(Array.prototype.splice.call(arguments, 1, arguments.length - 3));
-        });
-      };
+  exports.getValue = function(jq) {
+    return function() {
+      return jq.val();
     };
   };
-})(PS["Data.String.Regex"] = PS["Data.String.Regex"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Control_MonadPlus = PS["Control.MonadPlus"];
-  var Control_MonadZero = PS["Control.MonadZero"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
-  var Data_Monoid = PS["Data.Monoid"];
-  var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Show = PS["Data.Show"];
-  var Data_String = PS["Data.String"];
-  var Prelude = PS["Prelude"];        
-  var RegexFlags = (function () {
-      function RegexFlags(value0) {
-          this.value0 = value0;
-      };
-      RegexFlags.create = function (value0) {
-          return new RegexFlags(value0);
-      };
-      return RegexFlags;
-  })();
-  var global = new RegexFlags({
-      global: true,
-      ignoreCase: false,
-      multiline: false,
-      sticky: false,
-      unicode: false
-  });
-  exports["RegexFlags"] = RegexFlags;
-  exports["global"] = global;
-})(PS["Data.String.Regex.Flags"] = PS["Data.String.Regex.Flags"] || {});
+})(PS["JQuery.Extras"] = PS["JQuery.Extras"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.String.Regex"];
+  var $foreign = PS["JQuery.Extras"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Either = PS["Data.Either"];
-  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
   var Data_Maybe = PS["Data.Maybe"];
-  var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Show = PS["Data.Show"];
-  var Data_String = PS["Data.String"];
-  var Data_String_Regex_Flags = PS["Data.String.Regex.Flags"];
-  var Prelude = PS["Prelude"];                                                    
-  var renderFlags = function (v) {
-      return (function () {
-          if (v.value0.global) {
-              return "g";
-          };
-          return "";
-      })() + ((function () {
-          if (v.value0.ignoreCase) {
-              return "i";
-          };
-          return "";
-      })() + ((function () {
-          if (v.value0.multiline) {
-              return "m";
-          };
-          return "";
-      })() + ((function () {
-          if (v.value0.sticky) {
-              return "y";
-          };
-          return "";
-      })() + (function () {
-          if (v.value0.unicode) {
-              return "u";
-          };
-          return "";
-      })())));
-  };
-  var regex = function (s) {
-      return function (f) {
-          return $foreign["regex'"](Data_Either.Left.create)(Data_Either.Right.create)(s)(renderFlags(f));
-      };
-  };
-  exports["regex"] = regex;
-  exports["renderFlags"] = renderFlags;
-  exports["replace"] = $foreign.replace;
-  exports["replace'"] = $foreign["replace'"];
-})(PS["Data.String.Regex"] = PS["Data.String.Regex"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Data_Either = PS["Data.Either"];
-  var Data_String_Regex = PS["Data.String.Regex"];
-  var Data_String_Regex_Flags = PS["Data.String.Regex.Flags"];
-  var Partial_Unsafe = PS["Partial.Unsafe"];        
-  var unsafeRegex = function (s) {
-      return function (f) {
-          return Data_Either.fromRight()(Data_String_Regex.regex(s)(f));
-      };
+  var Data_Nullable = PS["Data.Nullable"];
+  var Effect = PS["Effect"];
+  var JQuery = PS["JQuery"];
+  var Prelude = PS["Prelude"];                 
+  var getValueMaybe = function ($0) {
+      return Data_Functor.map(Effect.functorEffect)(Data_Nullable.toMaybe)($foreign.getValue($0));
   };
-  exports["unsafeRegex"] = unsafeRegex;
-})(PS["Data.String.Regex.Unsafe"] = PS["Data.String.Regex.Unsafe"] || {});
+  exports["getValueMaybe"] = getValueMaybe;
+  exports["empty"] = $foreign.empty;
+  exports["fadeIn"] = $foreign.fadeIn;
+  exports["fadeOut"] = $foreign.fadeOut;
+  exports["filter"] = $foreign.filter;
+  exports["is"] = $foreign.is;
+})(PS["JQuery.Extras"] = PS["JQuery.Extras"] || {});
 (function(exports) {
     "use strict";
 
@@ -4404,9 +4974,9 @@ var PS = {};
   }
 })(PS["Try.API"] = PS["Try.API"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Data_Newtype = PS["Data.Newtype"];        
+  var Data_Newtype = PS["Data.Newtype"];                 
   var JS = function (x) {
       return x;
   };
@@ -4417,37 +4987,28 @@ var PS = {};
   exports["newtypeJS"] = newtypeJS;
 })(PS["Try.Types"] = PS["Try.Types"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Try.API"];
   var Control_Alt = PS["Control.Alt"];
   var Control_Category = PS["Control.Category"];
   var Control_Monad_Cont_Trans = PS["Control.Monad.Cont.Trans"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
-  var Control_Monad_Eff_Uncurried = PS["Control.Monad.Eff.Uncurried"];
   var Control_Monad_Except = PS["Control.Monad.Except"];
   var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
   var Control_Parallel = PS["Control.Parallel"];
   var Control_Parallel_Class = PS["Control.Parallel.Class"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var DOM = PS["DOM"];
   var Data_Array = PS["Data.Array"];
   var Data_Either = PS["Data.Either"];
   var Data_Eq = PS["Data.Eq"];
   var Data_Foldable = PS["Data.Foldable"];
-  var Data_Foreign = PS["Data.Foreign"];
-  var Data_Foreign_Class = PS["Data.Foreign.Class"];
-  var Data_Foreign_Generic = PS["Data.Foreign.Generic"];
-  var Data_Foreign_Generic_Class = PS["Data.Foreign.Generic.Class"];
-  var Data_Foreign_Generic_Types = PS["Data.Foreign.Generic.Types"];
-  var Data_Foreign_NullOrUndefined = PS["Data.Foreign.NullOrUndefined"];
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
   var Data_Generic_Rep = PS["Data.Generic.Rep"];
   var Data_Identity = PS["Data.Identity"];
   var Data_List_NonEmpty = PS["Data.List.NonEmpty"];
   var Data_List_Types = PS["Data.List.Types"];
+  var Data_Maybe = PS["Data.Maybe"];
   var Data_Monoid = PS["Data.Monoid"];
   var Data_Ord = PS["Data.Ord"];
   var Data_Ordering = PS["Data.Ordering"];
@@ -4457,6 +5018,14 @@ var PS = {};
   var Data_String_Regex_Unsafe = PS["Data.String.Regex.Unsafe"];
   var Data_Symbol = PS["Data.Symbol"];
   var Data_Traversable = PS["Data.Traversable"];
+  var Effect = PS["Effect"];
+  var Effect_Class = PS["Effect.Class"];
+  var Effect_Uncurried = PS["Effect.Uncurried"];
+  var Foreign = PS["Foreign"];
+  var Foreign_Class = PS["Foreign.Class"];
+  var Foreign_Generic = PS["Foreign.Generic"];
+  var Foreign_Generic_Class = PS["Foreign.Generic.Class"];
+  var Foreign_Generic_Types = PS["Foreign.Generic.Types"];
   var Partial_Unsafe = PS["Partial.Unsafe"];
   var Prelude = PS["Prelude"];
   var Try_Types = PS["Try.Types"];
@@ -4540,86 +5109,67 @@ var PS = {};
   })();
   var get = function (uri) {
       return function (k) {
-          return Control_Monad_Eff_Uncurried.runEffFn3($foreign.get_)(uri)(Control_Monad_Eff_Uncurried.mkEffFn1(function ($113) {
-              return k(Data_Either.Right.create($113));
-          }))(Control_Monad_Eff_Uncurried.mkEffFn1(function ($114) {
-              return k(Data_Either.Left.create($114));
-          }));
+          return function () {
+              return $foreign.get_(uri, function ($65) {
+                  return k(Data_Either.Right.create($65))();
+              }, function ($66) {
+                  return k(Data_Either.Left.create($66))();
+              });
+          };
       };
   };
   var getDefaultBundle = function (endpoint) {
-      return Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Control_Monad_Cont_Trans.functorContT(Control_Monad_Eff.functorEff)))(Try_Types.JS)(get(endpoint + "/bundle"));
+      return Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Control_Monad_Cont_Trans.functorContT(Effect.functorEffect)))(Try_Types.JS)(get(endpoint + "/bundle"));
   };
   var getThermiteBundle = function (endpoint) {
       var onComplete = function (dictPartial) {
           return function (v) {
-              var __unused = function (dictPartial1) {
-                  return function ($dollar35) {
-                      return $dollar35;
+              var $__unused = function (dictPartial1) {
+                  return function ($dollar26) {
+                      return $dollar26;
                   };
               };
-              return __unused(dictPartial)((function () {
+              return $__unused(dictPartial)((function () {
                   if (v.length === 4) {
                       var replaced = Data_String_Regex.replace(Data_String_Regex_Unsafe.unsafeRegex("require\\(\"react-dom\\/server\"\\)")(Data_String_Regex_Flags.global))("window.ReactDOM")(Data_String_Regex.replace(Data_String_Regex_Unsafe.unsafeRegex("require\\(\"react-dom\"\\)")(Data_String_Regex_Flags.global))("window.ReactDOM")(Data_String_Regex.replace(Data_String_Regex_Unsafe.unsafeRegex("require\\(\"react\"\\)")(Data_String_Regex_Flags.global))("window.React")(v[3])));
                       return Data_Foldable.intercalate(Data_Foldable.foldableArray)(Data_Monoid.monoidString)("\x0a")([ v[0], v[1], v[2], replaced ]);
                   };
-                  throw new Error("Failed pattern match at Try.API line 168, column 7 - line 170, column 23: " + [ v.constructor.name ]);
+                  throw new Error("Failed pattern match at Try.API line 164, column 7 - line 166, column 23: " + [ v.constructor.name ]);
               })());
           };
       };
-      var getAll = Control_Parallel.parTraverse(Control_Parallel_Class.monadParExceptT(Control_Parallel_Class.monadParParCont(Control_Monad_Eff_Class.monadEffEff)))(Data_Traversable.traversableArray)(get)([ "js/console.js", "js/react.min.js", "js/react-dom.min.js", endpoint + "/bundle" ]);
-      return Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Control_Monad_Cont_Trans.functorContT(Control_Monad_Eff.functorEff)))(onComplete())(getAll);
+      var getAll = Control_Parallel.parTraverse(Control_Parallel_Class.monadParExceptT(Control_Parallel_Class.monadParParCont(Effect_Class.monadEffectEffect)))(Data_Traversable.traversableArray)(get)([ "js/console.js", "js/react.min.js", "js/react-dom.min.js", endpoint + "/bundle" ]);
+      return Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Control_Monad_Cont_Trans.functorContT(Effect.functorEffect)))(onComplete())(getAll);
   };
   var genericSuggestion = new Data_Generic_Rep.Generic(function (x) {
-      return new Data_Generic_Rep.Product(x.replaceRange, x.replacement);
+      return x;
   }, function (x) {
-      return {
-          replaceRange: x.value0,
-          replacement: x.value1
-      };
+      return x;
   });
   var genericSuccessResult = new Data_Generic_Rep.Generic(function (x) {
-      return new Data_Generic_Rep.Product(x.js, x.warnings);
+      return x;
   }, function (x) {
-      return {
-          js: x.value0,
-          warnings: x.value1
-      };
+      return x;
   });
   var genericFailedResult = new Data_Generic_Rep.Generic(function (x) {
-      return x.error;
+      return x;
   }, function (x) {
-      return {
-          error: x
-      };
+      return x;
   });
   var genericErrorPosition = new Data_Generic_Rep.Generic(function (x) {
-      return new Data_Generic_Rep.Product(x.endColumn, new Data_Generic_Rep.Product(x.endLine, new Data_Generic_Rep.Product(x.startColumn, x.startLine)));
+      return x;
   }, function (x) {
-      return {
-          endColumn: x.value0,
-          endLine: x.value1.value0,
-          startColumn: x.value1.value1.value0,
-          startLine: x.value1.value1.value1
-      };
+      return x;
   });
   var genericCompilerError = new Data_Generic_Rep.Generic(function (x) {
-      return new Data_Generic_Rep.Product(x.message, x.position);
+      return x;
   }, function (x) {
-      return {
-          message: x.value0,
-          position: x.value1
-      };
+      return x;
   });
   var genericCompileWarning = new Data_Generic_Rep.Generic(function (x) {
-      return new Data_Generic_Rep.Product(x.errorCode, new Data_Generic_Rep.Product(x.message, new Data_Generic_Rep.Product(x.position, x.suggestion)));
+      return x;
   }, function (x) {
-      return {
-          errorCode: x.value0,
-          message: x.value1.value0,
-          position: x.value1.value1.value0,
-          suggestion: x.value1.value1.value1
-      };
+      return x;
   });
   var genericCompileError = new Data_Generic_Rep.Generic(function (x) {
       if (x instanceof CompilerErrors) {
@@ -4628,7 +5178,7 @@ var PS = {};
       if (x instanceof OtherError) {
           return new Data_Generic_Rep.Inr(x.value0);
       };
-      throw new Error("Failed pattern match at Try.API line 72, column 8 - line 72, column 62: " + [ x.constructor.name ]);
+      throw new Error("Failed pattern match at Try.API line 71, column 8 - line 71, column 62: " + [ x.constructor.name ]);
   }, function (x) {
       if (x instanceof Data_Generic_Rep.Inl) {
           return new CompilerErrors(x.value0);
@@ -4636,93 +5186,87 @@ var PS = {};
       if (x instanceof Data_Generic_Rep.Inr) {
           return new OtherError(x.value0);
       };
-      throw new Error("Failed pattern match at Try.API line 72, column 8 - line 72, column 62: " + [ x.constructor.name ]);
+      throw new Error("Failed pattern match at Try.API line 71, column 8 - line 71, column 62: " + [ x.constructor.name ]);
   });
-  var decodingOptions = (function () {
-      var $104 = {};
-      for (var $105 in Data_Foreign_Generic.defaultOptions) {
-          if ({}.hasOwnProperty.call(Data_Foreign_Generic.defaultOptions, $105)) {
-              $104[$105] = Data_Foreign_Generic["defaultOptions"][$105];
-          };
-      };
-      $104.unwrapSingleConstructors = true;
-      return $104;
-  })();
-  var decodeErrorPosition = new Data_Foreign_Class.Decode(Data_Foreign_Generic.genericDecode(genericErrorPosition)(Data_Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
+  var decodingOptions = {
+      sumEncoding: Foreign_Generic.defaultOptions.sumEncoding,
+      unwrapSingleConstructors: true,
+      unwrapSingleArguments: Foreign_Generic.defaultOptions.unwrapSingleArguments,
+      fieldTransform: Foreign_Generic.defaultOptions.fieldTransform
+  };
+  var decodeErrorPosition = new Foreign_Class.Decode(Foreign_Generic.genericDecode(genericErrorPosition)(Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
       return "ErrorPosition";
-  }))(Data_Foreign_Generic_Class.genericDecodeArgsRec(Data_Foreign_Generic_Class.genericDecodeFieldsProduct(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
-      return "endColumn";
-  }))(Data_Foreign_Class.intDecode))(Data_Foreign_Generic_Class.genericDecodeFieldsProduct(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
-      return "endLine";
-  }))(Data_Foreign_Class.intDecode))(Data_Foreign_Generic_Class.genericDecodeFieldsProduct(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
-      return "startColumn";
-  }))(Data_Foreign_Class.intDecode))(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
+  }))(Foreign_Generic_Class.genericDecodeArgsArgument(Foreign_Generic_Class.decode_Record()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordNil)(new Data_Symbol.IsSymbol(function () {
       return "startLine";
-  }))(Data_Foreign_Class.intDecode))))))(Data_Foreign_Generic_Class.genericCountArgsRec))(decodingOptions));
-  var decodeSuggestion = new Data_Foreign_Class.Decode(Data_Foreign_Generic.genericDecode(genericSuggestion)(Data_Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.intDecode))())(new Data_Symbol.IsSymbol(function () {
+      return "startColumn";
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.intDecode))())(new Data_Symbol.IsSymbol(function () {
+      return "endLine";
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.intDecode))())(new Data_Symbol.IsSymbol(function () {
+      return "endColumn";
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.intDecode))())))(Foreign_Generic_Class.genericCountArgsArgument))(decodingOptions));
+  var decodeSuggestion = new Foreign_Class.Decode(Foreign_Generic.genericDecode(genericSuggestion)(Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
       return "Suggestion";
-  }))(Data_Foreign_Generic_Class.genericDecodeArgsRec(Data_Foreign_Generic_Class.genericDecodeFieldsProduct(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
-      return "replaceRange";
-  }))(Data_Foreign_Class.decodeNullOrUndefined(decodeErrorPosition)))(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
+  }))(Foreign_Generic_Class.genericDecodeArgsArgument(Foreign_Generic_Class.decode_Record()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordNil)(new Data_Symbol.IsSymbol(function () {
       return "replacement";
-  }))(Data_Foreign_Class.stringDecode))))(Data_Foreign_Generic_Class.genericCountArgsRec))(decodingOptions));
-  var decodeCompilerError = new Data_Foreign_Class.Decode(Data_Foreign_Generic.genericDecode(genericCompilerError)(Data_Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.stringDecode))())(new Data_Symbol.IsSymbol(function () {
+      return "replaceRange";
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.maybeDecode(decodeErrorPosition)))())))(Foreign_Generic_Class.genericCountArgsArgument))(decodingOptions));
+  var decodeCompilerError = new Foreign_Class.Decode(Foreign_Generic.genericDecode(genericCompilerError)(Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
       return "CompilerError";
-  }))(Data_Foreign_Generic_Class.genericDecodeArgsRec(Data_Foreign_Generic_Class.genericDecodeFieldsProduct(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
-      return "message";
-  }))(Data_Foreign_Class.stringDecode))(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
+  }))(Foreign_Generic_Class.genericDecodeArgsArgument(Foreign_Generic_Class.decode_Record()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordNil)(new Data_Symbol.IsSymbol(function () {
       return "position";
-  }))(Data_Foreign_Class.decodeNullOrUndefined(decodeErrorPosition)))))(Data_Foreign_Generic_Class.genericCountArgsRec))(decodingOptions));
-  var decodeCompileWarning = new Data_Foreign_Class.Decode(Data_Foreign_Generic.genericDecode(genericCompileWarning)(Data_Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
-      return "CompileWarning";
-  }))(Data_Foreign_Generic_Class.genericDecodeArgsRec(Data_Foreign_Generic_Class.genericDecodeFieldsProduct(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
-      return "errorCode";
-  }))(Data_Foreign_Class.stringDecode))(Data_Foreign_Generic_Class.genericDecodeFieldsProduct(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.maybeDecode(decodeErrorPosition)))())(new Data_Symbol.IsSymbol(function () {
       return "message";
-  }))(Data_Foreign_Class.stringDecode))(Data_Foreign_Generic_Class.genericDecodeFieldsProduct(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
-      return "position";
-  }))(Data_Foreign_Class.decodeNullOrUndefined(decodeErrorPosition)))(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.stringDecode))())))(Foreign_Generic_Class.genericCountArgsArgument))(decodingOptions));
+  var decodeCompileWarning = new Foreign_Class.Decode(Foreign_Generic.genericDecode(genericCompileWarning)(Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
+      return "CompileWarning";
+  }))(Foreign_Generic_Class.genericDecodeArgsArgument(Foreign_Generic_Class.decode_Record()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordNil)(new Data_Symbol.IsSymbol(function () {
       return "suggestion";
-  }))(Data_Foreign_Class.decodeNullOrUndefined(decodeSuggestion)))))))(Data_Foreign_Generic_Class.genericCountArgsRec))(decodingOptions));                                  
-  var decodeCompileError = new Data_Foreign_Class.Decode(Data_Foreign_Generic.genericDecode(genericCompileError)(Data_Foreign_Generic_Class.genericDecodeSum(Data_Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.maybeDecode(decodeSuggestion)))())(new Data_Symbol.IsSymbol(function () {
+      return "position";
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.maybeDecode(decodeErrorPosition)))())(new Data_Symbol.IsSymbol(function () {
+      return "message";
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.stringDecode))())(new Data_Symbol.IsSymbol(function () {
+      return "errorCode";
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.stringDecode))())))(Foreign_Generic_Class.genericCountArgsArgument))(decodingOptions));
+  var decodeCompileError = new Foreign_Class.Decode(Foreign_Generic.genericDecode(genericCompileError)(Foreign_Generic_Class.genericDecodeSum(Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
       return "CompilerErrors";
-  }))(Data_Foreign_Generic_Class.genericDecodeArgsArgument(Data_Foreign_Class.arrayDecode(decodeCompilerError)))(Data_Foreign_Generic_Class.genericCountArgsArgument))(Data_Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
+  }))(Foreign_Generic_Class.genericDecodeArgsArgument(Foreign_Generic_Class.decode_Other(Foreign_Class.arrayDecode(decodeCompilerError))))(Foreign_Generic_Class.genericCountArgsArgument))(Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
       return "OtherError";
-  }))(Data_Foreign_Generic_Class.genericDecodeArgsArgument(Data_Foreign_Class.stringDecode))(Data_Foreign_Generic_Class.genericCountArgsArgument)))((function () {
-      var $107 = {};
-      for (var $108 in Data_Foreign_Generic.defaultOptions) {
-          if ({}.hasOwnProperty.call(Data_Foreign_Generic.defaultOptions, $108)) {
-              $107[$108] = Data_Foreign_Generic["defaultOptions"][$108];
-          };
-      };
-      $107.sumEncoding = new Data_Foreign_Generic_Types.TaggedObject({
+  }))(Foreign_Generic_Class.genericDecodeArgsArgument(Foreign_Generic_Class.decode_Other(Foreign_Class.stringDecode)))(Foreign_Generic_Class.genericCountArgsArgument)))({
+      sumEncoding: new Foreign_Generic_Types.TaggedObject({
           tagFieldName: "tag",
           contentsFieldName: "contents",
-          constructorTagTransform: Control_Category.id(Control_Category.categoryFn)
-      });
-      return $107;
-  })()));
-  var decodeCompileResult = new Data_Foreign_Class.Decode(function (f) {
-      return Control_Alt.alt(Control_Monad_Except_Trans.altExceptT(Data_List_Types.semigroupNonEmptyList)(Data_Identity.monadIdentity))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(CompileSuccess.create)(Data_Foreign_Generic.genericDecode(genericSuccessResult)(Data_Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
+          constructorTagTransform: Control_Category.identity(Control_Category.categoryFn)
+      }),
+      unwrapSingleConstructors: Foreign_Generic.defaultOptions.unwrapSingleConstructors,
+      unwrapSingleArguments: Foreign_Generic.defaultOptions.unwrapSingleArguments,
+      fieldTransform: Foreign_Generic.defaultOptions.fieldTransform
+  }));
+  var decodeCompileResult = new Foreign_Class.Decode(function (f) {
+      return Control_Alt.alt(Control_Monad_Except_Trans.altExceptT(Data_List_Types.semigroupNonEmptyList)(Data_Identity.monadIdentity))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(CompileSuccess.create)(Foreign_Generic.genericDecode(genericSuccessResult)(Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
           return "SuccessResult";
-      }))(Data_Foreign_Generic_Class.genericDecodeArgsRec(Data_Foreign_Generic_Class.genericDecodeFieldsProduct(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
-          return "js";
-      }))(Data_Foreign_Class.stringDecode))(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
+      }))(Foreign_Generic_Class.genericDecodeArgsArgument(Foreign_Generic_Class.decode_Record()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordNil)(new Data_Symbol.IsSymbol(function () {
           return "warnings";
-      }))(Data_Foreign_Class.decodeNullOrUndefined(Data_Foreign_Class.arrayDecode(decodeCompileWarning))))))(Data_Foreign_Generic_Class.genericCountArgsRec))(decodingOptions)(f)))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(CompileFailed.create)(Data_Foreign_Generic.genericDecode(genericFailedResult)(Data_Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
+      }))(Foreign_Generic_Class.decode_Other(Foreign_Class.maybeDecode(Foreign_Class.arrayDecode(decodeCompileWarning))))())(new Data_Symbol.IsSymbol(function () {
+          return "js";
+      }))(Foreign_Generic_Class.decode_Other(Foreign_Class.stringDecode))())))(Foreign_Generic_Class.genericCountArgsArgument))(decodingOptions)(f)))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(CompileFailed.create)(Foreign_Generic.genericDecode(genericFailedResult)(Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
           return "FailedResult";
-      }))(Data_Foreign_Generic_Class.genericDecodeArgsRec(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
+      }))(Foreign_Generic_Class.genericDecodeArgsArgument(Foreign_Generic_Class.decode_Record()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordNil)(new Data_Symbol.IsSymbol(function () {
           return "error";
-      }))(decodeCompileError)))(Data_Foreign_Generic_Class.genericCountArgsRec))(decodingOptions)(f)));
-  });                                                                                          
+      }))(Foreign_Generic_Class.decode_Other(decodeCompileError))())))(Foreign_Generic_Class.genericCountArgsArgument))(decodingOptions)(f)));
+  });                                                                                                                                 
   var compile = function (endpoint) {
       return function (code) {
           return function (k) {
-              return Control_Monad_Eff_Uncurried.runEffFn4($foreign.compile_)(endpoint)(code)(Control_Monad_Eff_Uncurried.mkEffFn1(function ($115) {
-                  return k(Data_Either.Right.create(Control_Monad_Except.runExcept(Data_Foreign_Class.decode(decodeCompileResult)($115))));
-              }))(Control_Monad_Eff_Uncurried.mkEffFn1(function ($116) {
-                  return k(Data_Either.Left.create($116));
-              }));
+              return function () {
+                  return $foreign.compile_(endpoint, code, function ($67) {
+                      return k(Data_Either.Right.create(Control_Monad_Except.runExcept(Foreign_Class.decode(decodeCompileResult)($67))))();
+                  }, function ($68) {
+                      return k(Data_Either.Left.create($68))();
+                  });
+              };
           };
       };
   };
@@ -4787,16 +5331,16 @@ var PS = {};
               getBundle: getDefaultBundle("https://compile.purescript.org/flare")
           };
       };
-      throw new Error("Failed pattern match at Try.API line 238, column 1 - line 238, column 45: " + [ v.constructor.name ]);
+      throw new Error("Failed pattern match at Try.API line 231, column 1 - line 231, column 45: " + [ v.constructor.name ]);
   };
   var backendFromString = function (dictPartial) {
       return function (v) {
-          var __unused = function (dictPartial1) {
-              return function ($dollar40) {
-                  return $dollar40;
+          var $__unused = function (dictPartial1) {
+              return function ($dollar31) {
+                  return $dollar31;
               };
           };
-          return __unused(dictPartial)((function () {
+          return $__unused(dictPartial)((function () {
               if (v === "core") {
                   return Core.value;
               };
@@ -4815,7 +5359,7 @@ var PS = {};
               if (v === "flare") {
                   return Flare.value;
               };
-              throw new Error("Failed pattern match at Try.API line 219, column 1 - line 219, column 50: " + [ v.constructor.name ]);
+              throw new Error("Failed pattern match at Try.API line 212, column 1 - line 212, column 50: " + [ v.constructor.name ]);
           })());
       };
   };
@@ -4899,44 +5443,49 @@ var PS = {};
   };
 })(PS["Try.Gist"] = PS["Try.Gist"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Try.Gist"];
   var Control_Monad_Cont_Trans = PS["Control.Monad.Cont.Trans"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Monad_Eff_Uncurried = PS["Control.Monad.Eff.Uncurried"];
   var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var DOM = PS["DOM"];
   var Data_Either = PS["Data.Either"];
-  var Prelude = PS["Prelude"];        
+  var Effect = PS["Effect"];
+  var Effect_Uncurried = PS["Effect.Uncurried"];
+  var Prelude = PS["Prelude"];                 
   var uploadGist = function (content) {
       return function (k) {
-          return Control_Monad_Eff_Uncurried.runEffFn3($foreign.uploadGist_)(content)(Control_Monad_Eff_Uncurried.mkEffFn1(function ($0) {
-              return k(Data_Either.Right.create($0));
-          }))(Control_Monad_Eff_Uncurried.mkEffFn1(function ($1) {
-              return k(Data_Either.Left.create($1));
-          }));
+          return function () {
+              return $foreign.uploadGist_(content, function ($0) {
+                  return k(Data_Either.Right.create($0))();
+              }, function ($1) {
+                  return k(Data_Either.Left.create($1))();
+              });
+          };
       };
   };
   var tryLoadFileFromGist = function (gi) {
       return function (filename) {
           return function (k) {
-              return Control_Monad_Eff_Uncurried.runEffFn4($foreign.tryLoadFileFromGist_)(gi)(filename)(Control_Monad_Eff_Uncurried.mkEffFn1(function ($2) {
-                  return k(Data_Either.Right.create($2));
-              }))(Control_Monad_Eff_Uncurried.mkEffFn1(function ($3) {
-                  return k(Data_Either.Left.create($3));
-              }));
+              return function () {
+                  return $foreign.tryLoadFileFromGist_(gi, filename, function ($2) {
+                      return k(Data_Either.Right.create($2))();
+                  }, function ($3) {
+                      return k(Data_Either.Left.create($3))();
+                  });
+              };
           };
       };
   };
   var getGistById = function (id_) {
       return function (k) {
-          return Control_Monad_Eff_Uncurried.runEffFn3($foreign.getGistById_)(id_)(Control_Monad_Eff_Uncurried.mkEffFn1(function ($4) {
-              return k(Data_Either.Right.create($4));
-          }))(Control_Monad_Eff_Uncurried.mkEffFn1(function ($5) {
-              return k(Data_Either.Left.create($5));
-          }));
+          return function () {
+              return $foreign.getGistById_(id_, function ($4) {
+                  return k(Data_Either.Right.create($4))();
+              }, function ($5) {
+                  return k(Data_Either.Left.create($5))();
+              });
+          };
       };
   };
   exports["uploadGist"] = uploadGist;
@@ -4959,53 +5508,55 @@ var PS = {};
   };
 })(PS["Try.QueryString"] = PS["Try.QueryString"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Try.QueryString"];
   var Control_Bind = PS["Control.Bind"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Monad_Eff_Uncurried = PS["Control.Monad.Eff.Uncurried"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var DOM = PS["DOM"];
   var Data_Array = PS["Data.Array"];
   var Data_Foldable = PS["Data.Foldable"];
   var Data_Functor = PS["Data.Functor"];
   var Data_Maybe = PS["Data.Maybe"];
   var Data_Newtype = PS["Data.Newtype"];
-  var Data_StrMap = PS["Data.StrMap"];
   var Data_String = PS["Data.String"];
+  var Data_String_CodePoints = PS["Data.String.CodePoints"];
+  var Data_String_Common = PS["Data.String.Common"];
+  var Data_String_Pattern = PS["Data.String.Pattern"];
   var Data_Tuple = PS["Data.Tuple"];
-  var Global = PS["Global"];
-  var Prelude = PS["Prelude"];        
+  var Effect = PS["Effect"];
+  var Effect_Uncurried = PS["Effect.Uncurried"];
+  var Foreign_Object = PS["Foreign.Object"];
+  var Global_Unsafe = PS["Global.Unsafe"];
+  var Prelude = PS["Prelude"];                 
   var getQueryParams = (function () {
-      var spaces = Data_String.replaceAll(Data_Newtype.wrap(Data_String.newtypePattern)("+"))(Data_Newtype.wrap(Data_String.newtypeReplacement)(" "));
+      var spaces = Data_String_Common.replaceAll(Data_Newtype.wrap(Data_String_Pattern.newtypePattern)("+"))(Data_Newtype.wrap(Data_String_Pattern.newtypeReplacement)(" "));
       var parseQueryTerm = function (v) {
           if (v.length === 2) {
-              return new Data_Maybe.Just(new Data_Tuple.Tuple(v[0], Global["decodeURIComponent"](spaces(v[1]))));
+              return new Data_Maybe.Just(new Data_Tuple.Tuple(v[0], Global_Unsafe.unsafeDecodeURIComponent(spaces(v[1]))));
           };
           return Data_Maybe.Nothing.value;
       };
       var breakQueryString = function ($6) {
           return (function ($7) {
-              return Data_StrMap.fromFoldable(Data_Foldable.foldableArray)(Data_Array.catMaybes(Data_Functor.map(Data_Functor.functorArray)(function ($8) {
-                  return parseQueryTerm(Data_String.split(Data_Newtype.wrap(Data_String.newtypePattern)("="))($8));
+              return Foreign_Object.fromFoldable(Data_Foldable.foldableArray)(Data_Array.catMaybes(Data_Functor.map(Data_Functor.functorArray)(function ($8) {
+                  return parseQueryTerm(Data_String_Common.split(Data_Newtype.wrap(Data_String_Pattern.newtypePattern)("="))($8));
               })($7)));
-          })(Data_String.split(Data_Newtype.wrap(Data_String.newtypePattern)("&"))(Data_String.drop(1)($6)));
+          })(Data_String_Common.split(Data_Newtype.wrap(Data_String_Pattern.newtypePattern)("&"))(Data_String_CodePoints.drop(1)($6)));
       };
-      return Data_Functor.map(Control_Monad_Eff.functorEff)(breakQueryString)($foreign.getQueryString);
+      return Data_Functor.map(Effect.functorEffect)(breakQueryString)($foreign.getQueryString);
   })();
   var getQueryStringMaybe = function (key) {
-      return Data_Functor.map(Control_Monad_Eff.functorEff)(Data_StrMap.lookup(key))(getQueryParams);
+      return Data_Functor.map(Effect.functorEffect)(Foreign_Object.lookup(key))(getQueryParams);
   };
   var setQueryStrings = function (ss) {
       return function __do() {
           var v = getQueryParams();
-          return Control_Monad_Eff_Uncurried.runEffFn1($foreign.setQueryParameters)(Data_StrMap.union(ss)(v))();
+          return $foreign.setQueryParameters(Foreign_Object.union(ss)(v));
       };
   };
   var setQueryString = function (k) {
       return function (v) {
-          return setQueryStrings(Data_StrMap.singleton(k)(v));
+          return setQueryStrings(Foreign_Object.singleton(k)(v));
       };
   };
   exports["getQueryParams"] = getQueryParams;
@@ -5034,16 +5585,12 @@ var PS = {};
   };
 })(PS["Try.Session"] = PS["Try.Session"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Try.Session"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Bind = PS["Control.Bind"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Monad_Eff_Random = PS["Control.Monad.Eff.Random"];
-  var Control_Monad_Eff_Uncurried = PS["Control.Monad.Eff.Uncurried"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var DOM = PS["DOM"];
   var Data_Functor = PS["Data.Functor"];
   var Data_Functor_App = PS["Data.Functor.App"];
   var Data_Int = PS["Data.Int"];
@@ -5054,24 +5601,32 @@ var PS = {};
   var Data_Semigroup = PS["Data.Semigroup"];
   var Data_Semiring = PS["Data.Semiring"];
   var Data_String = PS["Data.String"];
+  var Data_String_CodePoints = PS["Data.String.CodePoints"];
+  var Effect = PS["Effect"];
+  var Effect_Random = PS["Effect.Random"];
+  var Effect_Uncurried = PS["Effect.Uncurried"];
   var Prelude = PS["Prelude"];
-  var Try_QueryString = PS["Try.QueryString"];        
+  var Try_QueryString = PS["Try.QueryString"];                 
   var tryRetrieveSession = function (sessionId) {
-      return Data_Functor.map(Control_Monad_Eff.functorEff)(Data_Nullable.toMaybe)(Control_Monad_Eff_Uncurried.runEffFn1($foreign.tryRetrieveSession_)(sessionId));
+      return Data_Functor.map(Effect.functorEffect)(Data_Nullable.toMaybe)(function () {
+          return $foreign.tryRetrieveSession_(sessionId);
+      });
   };
   var storeSession = function (sessionId) {
       return function (values) {
-          return Control_Monad_Eff_Uncurried.runEffFn2($foreign.storeSession_)(sessionId)(values);
+          return function () {
+              return $foreign.storeSession_(sessionId, values);
+          };
       };
   };
   var randomGuid = (function () {
       var padLeft = function (s) {
-          return Data_String.drop(Data_String.length(s) - 1 | 0)("000" + s);
+          return Data_String_CodePoints.drop(Data_String_CodePoints.length(s) - 1 | 0)("000" + s);
       };
-      var s4 = Data_Functor.map(Control_Monad_Eff.functorEff)(function ($4) {
+      var s4 = Data_Functor.map(Effect.functorEffect)(function ($4) {
           return padLeft(Data_Int.toStringAs(Data_Int.hexadecimal)($4));
-      })(Control_Monad_Eff_Random.randomInt(0)(256 * 256 | 0));
-      return Data_Newtype.unwrap(Data_Functor_App.newtypeApp)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(Control_Applicative.pure(Data_Functor_App.applicativeApp(Control_Monad_Eff.applicativeEff))("-"))(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(Control_Applicative.pure(Data_Functor_App.applicativeApp(Control_Monad_Eff.applicativeEff))("-"))(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(Control_Applicative.pure(Data_Functor_App.applicativeApp(Control_Monad_Eff.applicativeEff))("-"))(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(Control_Applicative.pure(Data_Functor_App.applicativeApp(Control_Monad_Eff.applicativeEff))("-"))(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(s4)(s4))))))))))));
+      })(Effect_Random.randomInt(0)(256 * 256 | 0));
+      return Data_Newtype.unwrap(Data_Functor_App.newtypeApp)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(Control_Applicative.pure(Data_Functor_App.applicativeApp(Effect.applicativeEffect))("-"))(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(Control_Applicative.pure(Data_Functor_App.applicativeApp(Effect.applicativeEffect))("-"))(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(Control_Applicative.pure(Data_Functor_App.applicativeApp(Effect.applicativeEffect))("-"))(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(Control_Applicative.pure(Data_Functor_App.applicativeApp(Effect.applicativeEffect))("-"))(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(s4)(s4))))))))))));
   })();
   var createSessionIdIfNecessary = function (k) {
       return function __do() {
@@ -5080,9 +5635,9 @@ var PS = {};
               return k(v.value0)();
           };
           if (v instanceof Data_Maybe.Nothing) {
-              return Control_Bind.bind(Control_Monad_Eff.bindEff)(randomGuid)(Try_QueryString.setQueryString("session"))();
+              return Control_Bind.bind(Effect.bindEffect)(randomGuid)(Try_QueryString.setQueryString("session"))();
           };
-          throw new Error("Failed pattern match at Try.Session line 64, column 3 - line 66, column 46: " + [ v.constructor.name ]);
+          throw new Error("Failed pattern match at Try.Session line 57, column 3 - line 59, column 46: " + [ v.constructor.name ]);
       };
   };
   exports["storeSession"] = storeSession;
@@ -5090,33 +5645,178 @@ var PS = {};
   exports["createSessionIdIfNecessary"] = createSessionIdIfNecessary;
 })(PS["Try.Session"] = PS["Try.Session"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  /* global window */
+  "use strict";
+
+  exports.window = function () {
+    return window;
+  };
+})(PS["Web.HTML"] = PS["Web.HTML"] || {});
+(function(exports) {
+    "use strict";
+
+  // ----------------------------------------------------------------------------
+
+  exports.href = function (location) {
+    return function () {
+      return location.href;
+    };
+  };
+
+  exports.setHref = function (href) {
+    return function (location) {
+      return function () {
+        location.href = href;
+      };
+    };
+  };
+})(PS["Web.HTML.Location"] = PS["Web.HTML.Location"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Web.HTML.Location"];
+  var Effect = PS["Effect"];
+  var Prelude = PS["Prelude"];
+  exports["setHref"] = $foreign.setHref;
+})(PS["Web.HTML.Location"] = PS["Web.HTML.Location"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.location = function (window) {
+    return function () {
+      return window.location;
+    };
+  };
+
+  exports.alert = function (str) {
+    return function (window) {
+      return function () {
+        window.alert(str);
+        return {};
+      };
+    };
+  };
+
+  exports.confirm = function (str) {
+    return function (window) {
+      return function () {
+        return window.confirm(str);
+      };
+    };
+  };
+})(PS["Web.HTML.Window"] = PS["Web.HTML.Window"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Web.HTML.Window"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Newtype = PS["Data.Newtype"];
+  var Data_Nullable = PS["Data.Nullable"];
+  var Data_Ord = PS["Data.Ord"];
+  var Effect = PS["Effect"];
+  var Prelude = PS["Prelude"];
+  var Unsafe_Coerce = PS["Unsafe.Coerce"];
+  var Web_Event_EventTarget = PS["Web.Event.EventTarget"];
+  var Web_HTML_HTMLDocument = PS["Web.HTML.HTMLDocument"];
+  var Web_HTML_History = PS["Web.HTML.History"];
+  var Web_HTML_Location = PS["Web.HTML.Location"];
+  var Web_HTML_Navigator = PS["Web.HTML.Navigator"];
+  var Web_Storage_Storage = PS["Web.Storage.Storage"];
+  exports["location"] = $foreign.location;
+  exports["alert"] = $foreign.alert;
+  exports["confirm"] = $foreign.confirm;
+})(PS["Web.HTML.Window"] = PS["Web.HTML.Window"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Web.HTML"];
+  var Effect = PS["Effect"];
+  var Web_HTML_HTMLAnchorElement = PS["Web.HTML.HTMLAnchorElement"];
+  var Web_HTML_HTMLAreaElement = PS["Web.HTML.HTMLAreaElement"];
+  var Web_HTML_HTMLAudioElement = PS["Web.HTML.HTMLAudioElement"];
+  var Web_HTML_HTMLBRElement = PS["Web.HTML.HTMLBRElement"];
+  var Web_HTML_HTMLBaseElement = PS["Web.HTML.HTMLBaseElement"];
+  var Web_HTML_HTMLBodyElement = PS["Web.HTML.HTMLBodyElement"];
+  var Web_HTML_HTMLButtonElement = PS["Web.HTML.HTMLButtonElement"];
+  var Web_HTML_HTMLCanvasElement = PS["Web.HTML.HTMLCanvasElement"];
+  var Web_HTML_HTMLDListElement = PS["Web.HTML.HTMLDListElement"];
+  var Web_HTML_HTMLDataElement = PS["Web.HTML.HTMLDataElement"];
+  var Web_HTML_HTMLDataListElement = PS["Web.HTML.HTMLDataListElement"];
+  var Web_HTML_HTMLDivElement = PS["Web.HTML.HTMLDivElement"];
+  var Web_HTML_HTMLDocument = PS["Web.HTML.HTMLDocument"];
+  var Web_HTML_HTMLElement = PS["Web.HTML.HTMLElement"];
+  var Web_HTML_HTMLEmbedElement = PS["Web.HTML.HTMLEmbedElement"];
+  var Web_HTML_HTMLFieldSetElement = PS["Web.HTML.HTMLFieldSetElement"];
+  var Web_HTML_HTMLFormElement = PS["Web.HTML.HTMLFormElement"];
+  var Web_HTML_HTMLHRElement = PS["Web.HTML.HTMLHRElement"];
+  var Web_HTML_HTMLHeadElement = PS["Web.HTML.HTMLHeadElement"];
+  var Web_HTML_HTMLHeadingElement = PS["Web.HTML.HTMLHeadingElement"];
+  var Web_HTML_HTMLIFrameElement = PS["Web.HTML.HTMLIFrameElement"];
+  var Web_HTML_HTMLImageElement = PS["Web.HTML.HTMLImageElement"];
+  var Web_HTML_HTMLInputElement = PS["Web.HTML.HTMLInputElement"];
+  var Web_HTML_HTMLKeygenElement = PS["Web.HTML.HTMLKeygenElement"];
+  var Web_HTML_HTMLLIElement = PS["Web.HTML.HTMLLIElement"];
+  var Web_HTML_HTMLLabelElement = PS["Web.HTML.HTMLLabelElement"];
+  var Web_HTML_HTMLLegendElement = PS["Web.HTML.HTMLLegendElement"];
+  var Web_HTML_HTMLLinkElement = PS["Web.HTML.HTMLLinkElement"];
+  var Web_HTML_HTMLMapElement = PS["Web.HTML.HTMLMapElement"];
+  var Web_HTML_HTMLMediaElement = PS["Web.HTML.HTMLMediaElement"];
+  var Web_HTML_HTMLMetaElement = PS["Web.HTML.HTMLMetaElement"];
+  var Web_HTML_HTMLMeterElement = PS["Web.HTML.HTMLMeterElement"];
+  var Web_HTML_HTMLModElement = PS["Web.HTML.HTMLModElement"];
+  var Web_HTML_HTMLOListElement = PS["Web.HTML.HTMLOListElement"];
+  var Web_HTML_HTMLObjectElement = PS["Web.HTML.HTMLObjectElement"];
+  var Web_HTML_HTMLOptGroupElement = PS["Web.HTML.HTMLOptGroupElement"];
+  var Web_HTML_HTMLOptionElement = PS["Web.HTML.HTMLOptionElement"];
+  var Web_HTML_HTMLOutputElement = PS["Web.HTML.HTMLOutputElement"];
+  var Web_HTML_HTMLParagraphElement = PS["Web.HTML.HTMLParagraphElement"];
+  var Web_HTML_HTMLParamElement = PS["Web.HTML.HTMLParamElement"];
+  var Web_HTML_HTMLPreElement = PS["Web.HTML.HTMLPreElement"];
+  var Web_HTML_HTMLProgressElement = PS["Web.HTML.HTMLProgressElement"];
+  var Web_HTML_HTMLQuoteElement = PS["Web.HTML.HTMLQuoteElement"];
+  var Web_HTML_HTMLScriptElement = PS["Web.HTML.HTMLScriptElement"];
+  var Web_HTML_HTMLSelectElement = PS["Web.HTML.HTMLSelectElement"];
+  var Web_HTML_HTMLSourceElement = PS["Web.HTML.HTMLSourceElement"];
+  var Web_HTML_HTMLSpanElement = PS["Web.HTML.HTMLSpanElement"];
+  var Web_HTML_HTMLStyleElement = PS["Web.HTML.HTMLStyleElement"];
+  var Web_HTML_HTMLTableCaptionElement = PS["Web.HTML.HTMLTableCaptionElement"];
+  var Web_HTML_HTMLTableCellElement = PS["Web.HTML.HTMLTableCellElement"];
+  var Web_HTML_HTMLTableColElement = PS["Web.HTML.HTMLTableColElement"];
+  var Web_HTML_HTMLTableDataCellElement = PS["Web.HTML.HTMLTableDataCellElement"];
+  var Web_HTML_HTMLTableElement = PS["Web.HTML.HTMLTableElement"];
+  var Web_HTML_HTMLTableHeaderCellElement = PS["Web.HTML.HTMLTableHeaderCellElement"];
+  var Web_HTML_HTMLTableRowElement = PS["Web.HTML.HTMLTableRowElement"];
+  var Web_HTML_HTMLTableSectionElement = PS["Web.HTML.HTMLTableSectionElement"];
+  var Web_HTML_HTMLTemplateElement = PS["Web.HTML.HTMLTemplateElement"];
+  var Web_HTML_HTMLTextAreaElement = PS["Web.HTML.HTMLTextAreaElement"];
+  var Web_HTML_HTMLTimeElement = PS["Web.HTML.HTMLTimeElement"];
+  var Web_HTML_HTMLTitleElement = PS["Web.HTML.HTMLTitleElement"];
+  var Web_HTML_HTMLTrackElement = PS["Web.HTML.HTMLTrackElement"];
+  var Web_HTML_HTMLUListElement = PS["Web.HTML.HTMLUListElement"];
+  var Web_HTML_HTMLVideoElement = PS["Web.HTML.HTMLVideoElement"];
+  var Web_HTML_History = PS["Web.HTML.History"];
+  var Web_HTML_Location = PS["Web.HTML.Location"];
+  var Web_HTML_Navigator = PS["Web.HTML.Navigator"];
+  var Web_HTML_Window = PS["Web.HTML.Window"];
+  exports["window"] = $foreign.window;
+})(PS["Web.HTML"] = PS["Web.HTML"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Main"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Bind = PS["Control.Bind"];
   var Control_Monad_Cont_Trans = PS["Control.Monad.Cont.Trans"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Monad_Eff_Console = PS["Control.Monad.Eff.Console"];
-  var Control_Monad_Eff_JQuery = PS["Control.Monad.Eff.JQuery"];
-  var Control_Monad_Eff_JQuery_Extras = PS["Control.Monad.Eff.JQuery.Extras"];
-  var Control_Monad_Eff_Random = PS["Control.Monad.Eff.Random"];
-  var Control_Monad_Eff_Timer = PS["Control.Monad.Eff.Timer"];
-  var Control_Monad_Eff_Uncurried = PS["Control.Monad.Eff.Uncurried"];
   var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var DOM = PS["DOM"];
-  var DOM_HTML = PS["DOM.HTML"];
-  var DOM_HTML_Location = PS["DOM.HTML.Location"];
-  var DOM_HTML_Types = PS["DOM.HTML.Types"];
-  var DOM_HTML_Window = PS["DOM.HTML.Window"];
   var Data_Array = PS["Data.Array"];
   var Data_Either = PS["Data.Either"];
   var Data_Eq = PS["Data.Eq"];
   var Data_Foldable = PS["Data.Foldable"];
   var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
-  var Data_Foreign = PS["Data.Foreign"];
-  var Data_Foreign_NullOrUndefined = PS["Data.Foreign.NullOrUndefined"];
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
   var Data_List_Types = PS["Data.List.Types"];
@@ -5127,33 +5827,45 @@ var PS = {};
   var Data_Semigroup = PS["Data.Semigroup"];
   var Data_Semiring = PS["Data.Semiring"];
   var Data_Show = PS["Data.Show"];
-  var Data_StrMap = PS["Data.StrMap"];
   var Data_String = PS["Data.String"];
+  var Data_String_CodePoints = PS["Data.String.CodePoints"];
+  var Data_String_Common = PS["Data.String.Common"];
   var Data_String_Regex = PS["Data.String.Regex"];
   var Data_String_Regex_Flags = PS["Data.String.Regex.Flags"];
   var Data_String_Regex_Unsafe = PS["Data.String.Regex.Unsafe"];
   var Data_Unit = PS["Data.Unit"];
+  var Effect = PS["Effect"];
+  var Effect_Console = PS["Effect.Console"];
+  var Effect_Timer = PS["Effect.Timer"];
+  var Effect_Uncurried = PS["Effect.Uncurried"];
+  var Foreign = PS["Foreign"];
+  var Foreign_Object = PS["Foreign.Object"];
+  var JQuery = PS["JQuery"];
+  var JQuery_Extras = PS["JQuery.Extras"];
   var Prelude = PS["Prelude"];
   var Try_API = PS["Try.API"];
   var Try_Gist = PS["Try.Gist"];
   var Try_QueryString = PS["Try.QueryString"];
   var Try_Session = PS["Try.Session"];
-  var Try_Types = PS["Try.Types"];        
+  var Try_Types = PS["Try.Types"];
+  var Web_HTML = PS["Web.HTML"];
+  var Web_HTML_Location = PS["Web.HTML.Location"];
+  var Web_HTML_Window = PS["Web.HTML.Window"];                 
   var setTextAreaContent = function (value) {
-      return Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("#code_textarea"))(Control_Monad_Eff_JQuery.setValue(value));
+      return Control_Bind.bind(Effect.bindEffect)(JQuery.select("#code_textarea"))(JQuery.setValue(value));
   };
   var navigateTo = function (uri) {
-      return Data_Functor["void"](Control_Monad_Eff.functorEff)(Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Bind.bind(Control_Monad_Eff.bindEff)(DOM_HTML.window)(DOM_HTML_Window.location))(DOM_HTML_Location.setHref(uri)));
+      return Data_Functor["void"](Effect.functorEffect)(Control_Bind.bind(Effect.bindEffect)(Control_Bind.bind(Effect.bindEffect)(Web_HTML.window)(Web_HTML_Window.location))(Web_HTML_Location.setHref(uri)));
   };
   var loadFromGist = function (id_) {
       return function (backend) {
           return function (k) {
-              return Control_Monad_Cont_Trans.runContT(Control_Monad_Except_Trans.runExceptT(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Control_Monad_Cont_Trans.monadContT(Control_Monad_Eff.monadEff)))(Try_Gist.getGistById(id_))(function (gi) {
+              return Control_Monad_Cont_Trans.runContT(Control_Monad_Except_Trans.runExceptT(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Control_Monad_Cont_Trans.monadContT(Effect.monadEffect)))(Try_Gist.getGistById(id_))(function (gi) {
                   return Try_Gist.tryLoadFileFromGist(gi)("Main.purs");
               })))(function (v) {
                   if (v instanceof Data_Either.Left) {
                       return function __do() {
-                          Control_Bind.bind(Control_Monad_Eff.bindEff)(DOM_HTML.window)(DOM_HTML_Window.alert(v.value0))();
+                          Control_Bind.bind(Effect.bindEffect)(Web_HTML.window)(Web_HTML_Window.alert(v.value0))();
                           return k({
                               code: "",
                               backend: backend
@@ -5166,7 +5878,7 @@ var PS = {};
                           backend: backend
                       });
                   };
-                  throw new Error("Failed pattern match at Main line 293, column 5 - line 297, column 40: " + [ v.constructor.name ]);
+                  throw new Error("Failed pattern match at Main line 264, column 5 - line 268, column 40: " + [ v.constructor.name ]);
               });
           };
       };
@@ -5182,42 +5894,42 @@ var PS = {};
                   })();
               };
               if (v instanceof Data_Maybe.Nothing) {
-                  var v1 = Data_Functor.map(Control_Monad_Eff.functorEff)(function ($136) {
+                  var v1 = Data_Functor.map(Effect.functorEffect)(function ($136) {
                       return Try_API.getBackendConfigFromString(Data_Maybe.fromMaybe("core")($136));
                   })(Try_QueryString.getQueryStringMaybe("backend"))();
-                  var v2 = Data_Functor.map(Control_Monad_Eff.functorEff)(Data_Maybe.fromMaybe(v1.mainGist))(Try_QueryString.getQueryStringMaybe("gist"))();
+                  var v2 = Data_Functor.map(Effect.functorEffect)(Data_Maybe.fromMaybe(v1.mainGist))(Try_QueryString.getQueryStringMaybe("gist"))();
                   return loadFromGist(v2)(v1)(k)();
               };
-              throw new Error("Failed pattern match at Main line 319, column 3 - line 325, column 29: " + [ v.constructor.name ]);
+              throw new Error("Failed pattern match at Main line 276, column 3 - line 282, column 29: " + [ v.constructor.name ]);
           };
       };
   };
   var isShowJsChecked = function __do() {
-      var jq = Control_Monad_Eff_JQuery.select("#showjs")();
-      return Control_Monad_Eff_JQuery_Extras.is(jq)(":checked")();
+      var jq = JQuery.select("#showjs")();
+      return JQuery_Extras.is(jq)(":checked")();
   };
   var isAutoCompileChecked = function __do() {
-      var jq = Control_Monad_Eff_JQuery.select("#auto_compile")();
-      return Control_Monad_Eff_JQuery_Extras.is(jq)(":checked")();
+      var jq = JQuery.select("#auto_compile")();
+      return JQuery_Extras.is(jq)(":checked")();
   };
-  var hideLoadingMessage = Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("#loading"))(Control_Monad_Eff_JQuery_Extras.fadeOut);
-  var getTextAreaContent = Data_Functor.map(Control_Monad_Eff.functorEff)(Data_Foldable.fold(Data_Foldable.foldableMaybe)(Data_Monoid.monoidString))(Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("#code_textarea"))(Control_Monad_Eff_JQuery_Extras.getValueMaybe));
+  var hideLoadingMessage = Control_Bind.bind(Effect.bindEffect)(JQuery.select("#loading"))(JQuery_Extras.fadeOut);
+  var getTextAreaContent = Data_Functor.map(Effect.functorEffect)(Data_Foldable.fold(Data_Foldable.foldableMaybe)(Data_Monoid.monoidString))(Control_Bind.bind(Effect.bindEffect)(JQuery.select("#code_textarea"))(JQuery_Extras.getValueMaybe));
   var publishNewGist = function (v) {
       return function __do() {
-          var v1 = Control_Bind.bind(Control_Monad_Eff.bindEff)(DOM_HTML.window)(DOM_HTML_Window.confirm(Data_Foldable.intercalate(Data_Foldable.foldableArray)(Data_Monoid.monoidString)("\x0a")([ "Do you really want to publish this code as an anonymous Gist?", "", "Note: this code will be available to anyone with a link to the Gist." ])))();
-          return Control_Applicative.when(Control_Monad_Eff.applicativeEff)(v1)(function __do() {
+          var v1 = Control_Bind.bind(Effect.bindEffect)(Web_HTML.window)(Web_HTML_Window.confirm(Data_Foldable.intercalate(Data_Foldable.foldableArray)(Data_Monoid.monoidString)("\x0a")([ "Do you really want to publish this code as an anonymous Gist?", "", "Note: this code will be available to anyone with a link to the Gist." ])))();
+          return Control_Applicative.when(Effect.applicativeEffect)(v1)(function __do() {
               var v2 = getTextAreaContent();
               return Control_Monad_Cont_Trans.runContT(Control_Monad_Except_Trans.runExceptT(Try_Gist.uploadGist(v2)))(function (v3) {
                   if (v3 instanceof Data_Either.Left) {
                       return function __do() {
-                          Control_Bind.bind(Control_Monad_Eff.bindEff)(DOM_HTML.window)(DOM_HTML_Window.alert("Failed to create gist"))();
-                          return Control_Monad_Eff_Console.error("Failed to create gist: " + v3.value0)();
+                          Control_Bind.bind(Effect.bindEffect)(Web_HTML.window)(Web_HTML_Window.alert("Failed to create gist"))();
+                          return Effect_Console.error("Failed to create gist: " + v3.value0)();
                       };
                   };
                   if (v3 instanceof Data_Either.Right) {
-                      return Try_QueryString.setQueryStrings(Data_Semigroup.append(Data_StrMap.semigroupStrMap(Data_Semigroup.semigroupString))(Data_StrMap.singleton("gist")(v3.value0))(Data_StrMap.singleton("backend")(v.backend)));
+                      return Try_QueryString.setQueryStrings(Data_Semigroup.append(Foreign_Object.semigroupObject(Data_Semigroup.semigroupString))(Foreign_Object.singleton("gist")(v3.value0))(Foreign_Object.singleton("backend")(v.backend)));
                   };
-                  throw new Error("Failed pattern match at Main line 359, column 7 - line 365, column 71: " + [ v3.constructor.name ]);
+                  throw new Error("Failed pattern match at Main line 305, column 7 - line 311, column 71: " + [ v3.constructor.name ]);
               })();
           })();
       };
@@ -5227,53 +5939,55 @@ var PS = {};
           return function (v) {
               var replaced = Data_String_Regex["replace'"](Data_String_Regex_Unsafe.unsafeRegex("require\\(\"[^\"]*\"\\)")(Data_String_Regex_Flags.global))(function (s) {
                   return function (v1) {
-                      return "PS['" + (Data_String.drop(12)(Data_String.take(Data_String.length(s) - 2 | 0)(s)) + "']");
+                      return "PS['" + (Data_String_CodePoints.drop(12)(Data_String_CodePoints.take(Data_String_CodePoints.length(s) - 11 | 0)(s)) + "']");
                   };
               })(Data_Newtype.unwrap(Try_Types.newtypeJS)(js));
-              var wrapped = Data_String.joinWith("\x0a")([ "var module = {};", "(function(module) {", replaced, "})(module);", "module.exports.main && module.exports.main();" ]);
-              var scripts = Data_String.joinWith("\x0a")([ Data_Newtype.unwrap(Try_Types.newtypeJS)(bundle), wrapped ]);
-              var html = Data_String.joinWith("\x0a")([ "<!DOCTYPE html>", "<html>", "  <head>", "    <meta content=\"text/html;charset=utf-8\" http-equiv=\"Content-Type\">", "    <meta content=\"utf-8\" http-equiv=\"encoding\">", "    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">", "    <title>Try PureScript!</title>", "    <link rel=\"stylesheet\" href=\"css/style.css\">", v.extra_styling, "  </head>", "  <body>", v.extra_body, "  </body>", "</html>" ]);
+              var wrapped = Data_String_Common.joinWith("\x0a")([ "var module = {};", "(function(module) {", replaced, "})(module);", "module.exports.main && module.exports.main();" ]);
+              var scripts = Data_String_Common.joinWith("\x0a")([ Data_Newtype.unwrap(Try_Types.newtypeJS)(bundle), wrapped ]);
+              var html = Data_String_Common.joinWith("\x0a")([ "<!DOCTYPE html>", "<html>", "  <head>", "    <meta content=\"text/html;charset=utf-8\" http-equiv=\"Content-Type\">", "    <meta content=\"utf-8\" http-equiv=\"encoding\">", "    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">", "    <title>Try PureScript!</title>", "    <link rel=\"stylesheet\" href=\"css/style.css\">", v.extra_styling, "  </head>", "  <body>", v.extra_body, "  </body>", "</html>" ]);
               return function __do() {
-                  var v1 = Control_Monad_Eff_JQuery.select("#column2")();
-                  return Control_Monad_Eff_Uncurried.runEffFn3($foreign.setupIFrame)(v1)(html)(scripts)();
+                  var v1 = JQuery.select("#column2")();
+                  return $foreign.setupIFrame(v1, html, scripts);
               };
           };
       };
   };
   var displayPlainText = function (s) {
       return function __do() {
-          var v = Control_Monad_Eff_JQuery.select("#column2")();
-          Control_Monad_Eff_JQuery_Extras.empty(v)();
-          var v1 = Control_Monad_Eff_JQuery.create("<pre>")();
-          var v2 = Control_Monad_Eff_JQuery.create("<code>")();
-          Control_Monad_Eff_JQuery.append(v2)(v1)();
-          Control_Monad_Eff_JQuery.setText(s)(v2)();
-          return Control_Monad_Eff_JQuery.append(v1)(v)();
+          var v = JQuery.select("#column2")();
+          JQuery_Extras.empty(v)();
+          var v1 = JQuery.create("<pre>")();
+          var v2 = JQuery.create("<code>")();
+          JQuery.append(v2)(v1)();
+          JQuery.setText(s)(v2)();
+          return JQuery.append(v1)(v)();
       };
   };
-  var displayLoadingMessage = Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("#loading"))(Control_Monad_Eff_JQuery_Extras.fadeIn);
+  var displayLoadingMessage = Control_Bind.bind(Effect.bindEffect)(JQuery.select("#loading"))(JQuery_Extras.fadeIn);
   var displayErrors = function (errs) {
       return function __do() {
-          var v = Control_Monad_Eff_JQuery.select("#column2")();
-          Control_Monad_Eff_JQuery_Extras.empty(v)();
-          return Data_FoldableWithIndex.forWithIndex_(Control_Monad_Eff.applicativeEff)(Data_FoldableWithIndex.foldableWithIndexArray)(errs)(function (i) {
+          var v = JQuery.select("#column2")();
+          JQuery_Extras.empty(v)();
+          return Data_FoldableWithIndex.forWithIndex_(Effect.applicativeEffect)(Data_FoldableWithIndex.foldableWithIndexArray)(errs)(function (i) {
               return function (v1) {
                   return function __do() {
-                      var v2 = Control_Monad_Eff_JQuery.create("<h1>")();
-                      Control_Monad_Eff_JQuery.addClass("error-banner")(v2)();
-                      Control_Monad_Eff_JQuery.setText("Error " + (Data_Show.show(Data_Show.showInt)(i + 1 | 0) + (" of " + Data_Show.show(Data_Show.showInt)(Data_Array.length(errs)))))(v2)();
-                      var v3 = Control_Monad_Eff_JQuery.create("<pre>")();
-                      var v4 = Control_Monad_Eff_JQuery.create("<code>")();
-                      Control_Monad_Eff_JQuery.append(v4)(v3)();
-                      Control_Monad_Eff_JQuery.setText(v1.message)(v4)();
-                      Control_Monad_Eff_JQuery.append(v2)(v)();
-                      return Control_Monad_Eff_JQuery.append(v3)(v)();
+                      var v2 = JQuery.create("<h1>")();
+                      JQuery.addClass("error-banner")(v2)();
+                      JQuery.setText("Error " + (Data_Show.show(Data_Show.showInt)(i + 1 | 0) + (" of " + Data_Show.show(Data_Show.showInt)(Data_Array.length(errs)))))(v2)();
+                      var v3 = JQuery.create("<pre>")();
+                      var v4 = JQuery.create("<code>")();
+                      JQuery.append(v4)(v3)();
+                      JQuery.setText(v1.message)(v4)();
+                      JQuery.append(v2)(v)();
+                      return JQuery.append(v3)(v)();
                   };
               };
           })();
       };
   };
-  var clearAnnotations = Control_Monad_Eff_Uncurried.runEffFn1($foreign.setAnnotations)([  ]);
+  var clearAnnotations = function () {
+      return $foreign.setAnnotations([  ]);
+  };
   var compile = function (v) {
       return function __do() {
           var v1 = getTextAreaContent();
@@ -5296,12 +6010,12 @@ var PS = {};
                               return function __do() {
                                   hideLoadingMessage();
                                   if (bundleResult instanceof Data_Either.Left) {
-                                      return Control_Monad_Eff_Console.error("Unable to retrieve JS bundle: " + bundleResult.value0)();
+                                      return Effect_Console.error("Unable to retrieve JS bundle: " + bundleResult.value0)();
                                   };
                                   if (bundleResult instanceof Data_Either.Right) {
-                                      Data_Foldable.for_(Control_Monad_Eff.applicativeEff)(Data_Foldable.foldableMaybe)(Data_Newtype.unwrap(Data_Foreign_NullOrUndefined.newtypeNullOrUndefined)(res_.value0.value0.value0.warnings))(function (warnings_) {
+                                      Data_Foldable.for_(Effect.applicativeEffect)(Data_Foldable.foldableMaybe)(res_.value0.value0.value0.warnings)(function (warnings_) {
                                           var toAnnotation = function (v3) {
-                                              return Data_Functor.mapFlipped(Data_Maybe.functorMaybe)(Data_Newtype.unwrap(Data_Foreign_NullOrUndefined.newtypeNullOrUndefined)(v3.position))(function (v4) {
+                                              return Data_Functor.mapFlipped(Data_Maybe.functorMaybe)(v3.position)(function (v4) {
                                                   return {
                                                       row: v4.startLine - 1 | 0,
                                                       column: v4.startColumn - 1 | 0,
@@ -5310,11 +6024,13 @@ var PS = {};
                                                   };
                                               });
                                           };
-                                          return Control_Monad_Eff_Uncurried.runEffFn1($foreign.setAnnotations)(Data_Array.mapMaybe(toAnnotation)(warnings_));
+                                          return function () {
+                                              return $foreign.setAnnotations(Data_Array.mapMaybe(toAnnotation)(warnings_));
+                                          };
                                       })();
                                       return execute(res_.value0.value0.value0.js)(bundleResult.value0)(v)();
                                   };
-                                  throw new Error("Failed pattern match at Main line 159, column 22 - line 171, column 51: " + [ bundleResult.constructor.name ]);
+                                  throw new Error("Failed pattern match at Main line 151, column 22 - line 163, column 51: " + [ bundleResult.constructor.name ]);
                               };
                           })();
                       };
@@ -5323,7 +6039,7 @@ var PS = {};
                           if (res_.value0.value0.value0.error instanceof Try_API.CompilerErrors) {
                               displayErrors(res_.value0.value0.value0.error.value0)();
                               var toAnnotation = function (v2) {
-                                  return Data_Functor.mapFlipped(Data_Maybe.functorMaybe)(Data_Newtype.unwrap(Data_Foreign_NullOrUndefined.newtypeNullOrUndefined)(v2.position))(function (v3) {
+                                  return Data_Functor.mapFlipped(Data_Maybe.functorMaybe)(v2.position)(function (v3) {
                                       return {
                                           row: v3.startLine - 1 | 0,
                                           column: v3.startColumn - 1 | 0,
@@ -5332,35 +6048,37 @@ var PS = {};
                                       };
                                   });
                               };
-                              Control_Monad_Eff_Uncurried.runEffFn1($foreign.setAnnotations)(Data_Array.mapMaybe(toAnnotation)(res_.value0.value0.value0.error.value0))();
-                              return Data_Foldable.for_(Control_Monad_Eff.applicativeEff)(Data_Foldable.foldableArray)(res_.value0.value0.value0.error.value0)(function (v2) {
-                                  return Data_Foldable.for_(Control_Monad_Eff.applicativeEff)(Data_Foldable.foldableMaybe)(Data_Newtype.unwrap(Data_Foreign_NullOrUndefined.newtypeNullOrUndefined)(v2.position))(function (v3) {
-                                      return Control_Monad_Eff_Uncurried.runEffFn5($foreign.addMarker)("error")(v3.startLine)(v3.startColumn)(v3.endLine)(v3.endColumn);
+                              $foreign.setAnnotations(Data_Array.mapMaybe(toAnnotation)(res_.value0.value0.value0.error.value0));
+                              return Data_Foldable.for_(Effect.applicativeEffect)(Data_Foldable.foldableArray)(res_.value0.value0.value0.error.value0)(function (v2) {
+                                  return Data_Foldable.for_(Effect.applicativeEffect)(Data_Foldable.foldableMaybe)(v2.position)(function (v3) {
+                                      return function () {
+                                          return $foreign.addMarker("error", v3.startLine, v3.startColumn, v3.endLine, v3.endColumn);
+                                      };
                                   });
                               })();
                           };
                           if (res_.value0.value0.value0.error instanceof Try_API.OtherError) {
                               return displayPlainText(res_.value0.value0.value0.error.value0)();
                           };
-                          throw new Error("Failed pattern match at Main line 174, column 13 - line 195, column 53: " + [ res_.value0.value0.value0.error.constructor.name ]);
+                          throw new Error("Failed pattern match at Main line 166, column 13 - line 187, column 53: " + [ res_.value0.value0.value0.error.constructor.name ]);
                       };
                       if (res_.value0 instanceof Data_Either.Left) {
                           hideLoadingMessage();
                           displayPlainText("Unable to parse the response from the server")();
-                          return Data_Foldable.traverse_(Control_Monad_Eff.applicativeEff)(Data_List_Types.foldableNonEmptyList)(function ($137) {
-                              return Control_Monad_Eff_Console.error(Data_Foreign.renderForeignError($137));
+                          return Data_Foldable.traverse_(Effect.applicativeEffect)(Data_List_Types.foldableNonEmptyList)(function ($137) {
+                              return Effect_Console.error(Foreign.renderForeignError($137));
                           })(res_.value0.value0)();
                       };
-                      throw new Error("Failed pattern match at Main line 151, column 9 - line 199, column 58: " + [ res_.value0.constructor.name ]);
+                      throw new Error("Failed pattern match at Main line 143, column 9 - line 191, column 58: " + [ res_.value0.constructor.name ]);
                   };
               };
-              throw new Error("Failed pattern match at Main line 146, column 5 - line 199, column 58: " + [ res_.constructor.name ]);
+              throw new Error("Failed pattern match at Main line 138, column 5 - line 191, column 58: " + [ res_.constructor.name ]);
           })();
       };
   };
   var changeViewMode = function (viewMode) {
-      return Data_Foldable.for_(Control_Monad_Eff.applicativeEff)(Data_Foldable.foldableMaybe)(viewMode)(function (viewMode_) {
-          return Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("#editor_view"))(Control_Monad_Eff_JQuery.setAttr("data-view-mode")(viewMode_));
+      return Data_Foldable.for_(Effect.applicativeEffect)(Data_Foldable.foldableMaybe)(viewMode)(function (viewMode_) {
+          return Control_Bind.bind(Effect.bindEffect)(JQuery.select("#editor_view"))(JQuery.setAttr("data-view-mode")(viewMode_));
       });
   };
   var loadOptions = function (bc) {
@@ -5368,34 +6086,34 @@ var PS = {};
           var v = Try_QueryString.getQueryStringMaybe("view")();
           (function () {
               if (v instanceof Data_Maybe.Just && Data_Foldable.elem(Data_Foldable.foldableArray)(Data_Eq.eqString)(v.value0)([ "sidebyside", "code", "output" ])) {
-                  return changeViewMode(v);
+                  return changeViewMode(v)();
               };
-              return Control_Applicative.pure(Control_Monad_Eff.applicativeEff)(Data_Unit.unit);
-          })()();
+              return Data_Unit.unit;
+          })();
           var v1 = Try_QueryString.getQueryStringMaybe("js")();
           (function () {
               if (v1 instanceof Data_Maybe.Just) {
-                  return Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("input:checkbox[name=showjs]"))(Control_Monad_Eff_JQuery.setProp("checked")(v1.value0 === "true"));
+                  return Control_Bind.bind(Effect.bindEffect)(JQuery.select("input:checkbox[name=showjs]"))(JQuery.setProp("checked")(v1.value0 === "true"))();
               };
-              return Control_Applicative.pure(Control_Monad_Eff.applicativeEff)(Data_Unit.unit);
-          })()();
+              return Data_Unit.unit;
+          })();
           var v2 = Try_QueryString.getQueryStringMaybe("compile")();
           (function () {
               if (v2 instanceof Data_Maybe.Just) {
-                  return Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("input:checkbox[name=auto_compile]"))(Control_Monad_Eff_JQuery.setProp("checked")(v2.value0 === "true"));
+                  return Control_Bind.bind(Effect.bindEffect)(JQuery.select("input:checkbox[name=auto_compile]"))(JQuery.setProp("checked")(v2.value0 === "true"))();
               };
-              return Control_Applicative.pure(Control_Monad_Eff.applicativeEff)(Data_Unit.unit);
-          })()();
+              return Data_Unit.unit;
+          })();
           var v3 = Try_QueryString.getQueryStringMaybe("gist")();
           if (v3 instanceof Data_Maybe.Just) {
-              return Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select(".view_gist"))(Control_Monad_Eff_JQuery.attr({
+              return Control_Bind.bind(Effect.bindEffect)(JQuery.select(".view_gist"))(JQuery.attr({
                   href: "https://gist.github.com/" + v3.value0
               }))();
           };
           if (v3 instanceof Data_Maybe.Nothing) {
-              return Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select(".view_gist_li"))(Control_Monad_Eff_JQuery.hide)();
+              return Control_Bind.bind(Effect.bindEffect)(JQuery.select(".view_gist_li"))(JQuery.hide)();
           };
-          throw new Error("Failed pattern match at Main line 402, column 3 - line 404, column 61: " + [ v3.constructor.name ]);
+          throw new Error("Failed pattern match at Main line 340, column 3 - line 342, column 61: " + [ v3.constructor.name ]);
       };
   };
   var cacheCurrentCode = function (v) {
@@ -5409,27 +6127,27 @@ var PS = {};
               })();
           };
           if (v1 instanceof Data_Maybe.Nothing) {
-              return Control_Monad_Eff_Console.error("No session ID")();
+              return Effect_Console.error("No session ID")();
           };
-          throw new Error("Failed pattern match at Main line 334, column 3 - line 340, column 1: " + [ v1.constructor.name ]);
+          throw new Error("Failed pattern match at Main line 288, column 3 - line 294, column 1: " + [ v1.constructor.name ]);
       };
   };
   var setupBackendMenu = function (v) {
       return function __do() {
-          Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("#backend_" + v.backend))(Control_Monad_Eff_JQuery.attr({
+          Control_Bind.bind(Effect.bindEffect)(JQuery.select("#backend_" + v.backend))(JQuery.attr({
               checked: "checked"
           }))();
-          return Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("input[name=backend_inputs]"))(Control_Monad_Eff_JQuery.on("change")(function (e) {
+          return Control_Bind.bind(Effect.bindEffect)(JQuery.select("input[name=backend_inputs]"))(JQuery.on("change")(function (e) {
               return function (jq) {
                   return function __do() {
-                      var v1 = Data_Functor.map(Control_Monad_Eff.functorEff)(function ($138) {
+                      var v1 = Data_Functor.map(Effect.functorEffect)(function ($138) {
                           return Try_API.getBackendConfigFromString(Data_Maybe.fromMaybe("core")($138));
-                      })(Control_Monad_Eff_JQuery_Extras.getValueMaybe(jq))();
-                      var v2 = Control_Bind.bind(Control_Monad_Eff.bindEff)(DOM_HTML.window)(DOM_HTML_Window.confirm("Replace your current code with the " + (v1.backend + " backend sample code?")))();
+                      })(JQuery_Extras.getValueMaybe(jq))();
+                      var v2 = Control_Bind.bind(Effect.bindEffect)(Web_HTML.window)(Web_HTML_Window.confirm("Replace your current code with the " + (v1.backend + " backend sample code?")))();
                       if (v2) {
                           return navigateTo("?backend=" + v1.backend)();
                       };
-                      return Data_Functor["void"](Control_Monad_Eff.functorEff)(Control_Monad_Eff_Timer.setTimeout(1000)(function __do() {
+                      return Data_Functor["void"](Effect.functorEffect)(Effect_Timer.setTimeout(1000)(function __do() {
                           compile(v1)();
                           return cacheCurrentCode(v1)();
                       }))();
@@ -5443,26 +6161,24 @@ var PS = {};
           loadOptions(v.backend)();
           setupBackendMenu(v.backend)();
           setTextAreaContent(v.code)();
-          Control_Monad_Eff_Uncurried.runEffFn1($foreign.setEditorContent)(v.code)();
-          Control_Monad_Eff_Uncurried.runEffFn2($foreign.onEditorChanged)(Control_Monad_Eff_Uncurried.mkEffFn1(function (value) {
-              return function __do() {
-                  setTextAreaContent(value)();
-                  cacheCurrentCode(v.backend)();
-                  var v1 = isAutoCompileChecked();
-                  return Control_Applicative.when(Control_Monad_Eff.applicativeEff)(v1)(compile(v.backend))();
-              };
-          }))(750)();
-          Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("#showjs"))(Control_Monad_Eff_JQuery.on("change")(function (e) {
+          $foreign.setEditorContent(v.code);
+          $foreign.onEditorChanged(function (value) {
+              setTextAreaContent(value)();
+              cacheCurrentCode(v.backend)();
+              var v1 = isAutoCompileChecked();
+              return Control_Applicative.when(Effect.applicativeEffect)(v1)(compile(v.backend))();
+          }, 750);
+          Control_Bind.bind(Effect.bindEffect)(JQuery.select("#showjs"))(JQuery.on("change")(function (e) {
               return function (v1) {
                   return compile(v.backend);
               };
           }))();
-          Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("#compile_label"))(Control_Monad_Eff_JQuery.on("click")(function (e) {
+          Control_Bind.bind(Effect.bindEffect)(JQuery.select("#compile_label"))(JQuery.on("click")(function (e) {
               return function (v1) {
                   return compile(v.backend);
               };
           }))();
-          Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("#gist_save"))(Control_Monad_Eff_JQuery.on("click")(function (e) {
+          Control_Bind.bind(Effect.bindEffect)(JQuery.select("#gist_save"))(JQuery.on("click")(function (e) {
               return function (v1) {
                   return publishNewGist(v.backend);
               };
@@ -5471,16 +6187,16 @@ var PS = {};
           return cacheCurrentCode(v.backend)();
       };
   };
-  var main = Control_Monad_Eff_JQuery.ready(function __do() {
-      Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("input[name=view_mode]"))(Control_Monad_Eff_JQuery.on("change")(function (v) {
+  var main = JQuery.ready(function __do() {
+      Control_Bind.bind(Effect.bindEffect)(JQuery.select("input[name=view_mode]"))(JQuery.on("change")(function (v) {
           return function (jq) {
               return function __do() {
-                  var v1 = Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery_Extras.filter(jq)(":checked"))(Control_Monad_Eff_JQuery_Extras.getValueMaybe)();
+                  var v1 = Control_Bind.bind(Effect.bindEffect)(JQuery_Extras.filter(jq)(":checked"))(JQuery_Extras.getValueMaybe)();
                   return changeViewMode(v1)();
               };
           };
       }))();
-      return Control_Monad_Cont_Trans.runContT(Control_Bind.bind(Control_Monad_Cont_Trans.bindContT(Control_Monad_Eff.bindEff))(Try_Session.createSessionIdIfNecessary)(function (v) {
+      return Control_Monad_Cont_Trans.runContT(Control_Bind.bind(Control_Monad_Cont_Trans.bindContT(Effect.bindEffect))(Try_Session.createSessionIdIfNecessary)(function (v) {
           return withSession(v);
       }))(setupEditor)();
   });
@@ -5512,4 +6228,4 @@ var PS = {};
   exports["setAnnotations"] = $foreign.setAnnotations;
   exports["setupIFrame"] = $foreign.setupIFrame;
 })(PS["Main"] = PS["Main"] || {});
-PS["Main"].main();
+PS["Main"].main();
\ No newline at end of file
diff --git a/src/Main.purs b/src/Main.purs
index 6f15ee91..5ae596ff 100644
--- a/src/Main.purs
+++ b/src/Main.purs
@@ -211,7 +211,7 @@ execute js bundle bc@(BackendConfig backend) = do
         ]
 
       replaced = replace' (unsafeRegex """require\("[^"]*"\)""" global) (\s _ ->
-        "PS['" <> String.drop 12 (String.take (String.length s - 2) s) <> "']") (unwrap js)
+        "PS['" <> String.drop 12 (String.take (String.length s - 11) s) <> "']") (unwrap js)
 
       wrapped = joinWith "\n"
         [ "var module = {};"