yesod-auth-hmac-keccak (empty) → 0.0.0.1
raw patch · 16 files changed
+33233/−0 lines, 16 filesdep +aesondep +basedep +bytestringbuild-type:Customsetup-changed
Dependencies added: aeson, base, bytestring, cryptonite, mtl, persistent, random, shakespeare, text, yesod-auth, yesod-core, yesod-form, yesod-persistent, yesod-static
Files
- ChangeLog.md +5/−0
- LICENSE +20/−0
- Setup.hs +71/−0
- bower.json +24/−0
- hssrc/Yesod/Auth/HmacKeccak.hs +648/−0
- hssrc/Yesod/Auth/Import.hs +22/−0
- hssrc/Yesod/Auth/JsPath.hs +8/−0
- hssrc/Yesod/Auth/Message.hs +57/−0
- hssrc/Yesod/Auth/Types.hs +5/−0
- src/Activate.purs +79/−0
- src/Common.js +37/−0
- src/Common.purs +97/−0
- src/Login.purs +104/−0
- src/Main.purs +30/−0
- static/js/auth.js +31966/−0
- yesod-auth-hmac-keccak.cabal +60/−0
+ ChangeLog.md view
@@ -0,0 +1,5 @@+# Revision history for yesod-auth-hmac-keccak++## 0.0.0.0 -- YYYY-mm-dd++* First version. Released on an unsuspecting world.
+ LICENSE view
@@ -0,0 +1,20 @@+Copyright (c) 2017 nek0++Permission is hereby granted, free of charge, to any person obtaining+a copy of this software and associated documentation files (the+"Software"), to deal in the Software without restriction, including+without limitation the rights to use, copy, modify, merge, publish,+distribute, sublicense, and/or sell copies of the Software, and to+permit persons to whom the Software is furnished to do so, subject to+the following conditions:++The above copyright notice and this permission notice shall be included+in all copies or substantial portions of the Software.++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ Setup.hs view
@@ -0,0 +1,71 @@+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE PartialTypeSignatures #-}++import Distribution.Simple+import Distribution.PackageDescription (HookedBuildInfo, emptyHookedBuildInfo)+import Language.PureScript.Make+import Language.PureScript.Names+import Language.PureScript.Options+import Language.PureScript.AST.Declarations+import Language.PureScript.Parser.Declarations (parseModulesFromFiles)++import System.Process++import qualified Data.Map as M+import qualified Data.Text as T+import Data.Text.Encoding+import Data.Maybe (fromJust)+import qualified Data.ByteString.Lazy as BL+import qualified Data.ByteString as BS++import Debug.Trace++main = defaultMainWithHooks simpleUserHooks+ { -- preBuild = preBuild'+ preConf = preConf'+ }++preConf' :: _ -> _ -> IO HookedBuildInfo+preConf' _ _ = do+ traceM "Installing purescript dependencies"+ run11 <- readProcess "/usr/local/bin/bower" ["install"] []+ run12 <- readProcess "/usr/bin/npm" ["install", "crypto-js"] []+ traceM "Compiling purescript files"+ run21 <- readProcess "/bin/mkdir" ["-p", "static/js"] []+ run22 <- readProcess "/usr/local/bin/pulp" ["browserify" , "-t" , "./static/js/auth.js"] []+ return emptyHookedBuildInfo++-- preBuild' :: _ -> _ -> IO HookedBuildInfo+-- preBuild' _ _ = do+-- exts <- runMake defaultOptions $ do+-- traceM "im in here!"+-- !src <- makeIO (const $ error "error") $ glob "src/*.purs"+-- traceM $ show src+-- traceM "reading in sources"+-- !dep <- makeIO (const $ error "error") $ glob+-- "bower_components/purescript-*/src/**/*.purs"+-- traceM $ show dep+-- traceM "reading in dependencies"+-- !content <- zip [1..] <$> mapM (\s -> do+-- cont <- readTextFile s+-- return $ decodeUtf8 $ toStrict cont+-- ) (dep ++ src)+-- !mods <- parseModulesFromFiles+-- (fromJust . flip lookup (zip [1..] (dep ++ src)))+-- content+-- let !srcMap = M.fromList $ zip (map getModuleName $ map snd mods)+-- (map Right (dep ++ src))+-- traceM "building srcMap"+-- !fgn <- inferForeignModules srcMap+-- traceM "infering foreign modules"+-- let !ma = buildMakeActions "static/js" srcMap fgn True+-- traceM "built MakeActions"+-- traceM "parsing modules"+-- make ma (map snd mods)+-- traceM "made"+-- traceM $ show exts+-- return emptyHookedBuildInfo+--+-- toStrict :: BL.ByteString -> BS.ByteString+-- toStrict = BS.concat . BL.toChunks
+ bower.json view
@@ -0,0 +1,24 @@+{+ "name": "yesod-auth-hmac-keccak",+ "authors": [+ "nek0 <nek0@chelnok.de>"+ ],+ "description": "",+ "main": "",+ "license": "MIT",+ "homepage": "",+ "ignore": [+ "**/.*",+ "node_modules",+ "bower_components",+ "test",+ "tests"+ ],+ "dependencies": {+ "purescript-react-dom": "^3.0.0",+ "purescript-argonaut": "^3.0.0",+ "purescript-affjax": "^4.0.0",+ "purescript-jquery": "^4.0.0",+ "purescript-dom": "^4.2.0"+ }+}
+ hssrc/Yesod/Auth/HmacKeccak.hs view
@@ -0,0 +1,648 @@+{-# LANGUAGE+ CPP+, OverloadedStrings+, RecordWildCards+, QuasiQuotes+, TemplateHaskell+, TypeFamilies+, TypeOperators+, MultiParamTypeClasses+, FunctionalDependencies+, FlexibleContexts+, FlexibleInstances+, AllowAmbiguousTypes+, UndecidableInstances+, GeneralizedNewtypeDeriving+, ScopedTypeVariables+, TypeFamilyDependencies #-}++module Yesod.Auth.HmacKeccak where++import Yesod.Auth.Import+import qualified Data.Text as T+import qualified Data.Char as C+import qualified Data.ByteString as B+import qualified Data.ByteString.Lazy as BL+import qualified Data.ByteString.Char8 as BC+import Data.Maybe (fromJust)++import qualified Database.Persist as P++import System.Random+import System.IO.Unsafe (unsafePerformIO)++import Numeric (readHex, showHex)++import Yesod.Auth+import Yesod.Auth.Message+import Yesod.Persist hiding (get, replace, insertkey, Entity, entityVal)+import Yesod.Static++import Text.Julius (jsFile)++import Paths_yesod_auth_hmac_keccak as Paths+import Yesod.Auth.JsPath++type Username = Text++-- js_auth_js :: String+-- js_auth_js =+-- unsafePerformIO $ readFile =<< getDataFileName "static/js/auth.js"++hmacPlugin+ :: YesodHmacKeccak db master+ => AuthPlugin master+hmacPlugin = AuthPlugin "authHmacKeccak" dispatch loginWidget+ where+ dispatch "POST" ["login"] = postLoginR' >>= sendResponse+ dispatch "GET" ["newaccount"] = getNewAccountR' >>= sendResponse+ dispatch "POST" ["newaccount"] = postNewAccountR' >>= sendResponse+ dispatch "GET" ["resetpasswd"] = getReactivateR' >>= sendResponse+ dispatch "POST" ["resetpasswd"] = postReactivateR' >>= sendResponse+ dispatch "GET" ["verify", k] = getVerifyR' (encodeUtf8 k) >>= sendResponse+ dispatch "POST" ["verify", k] = postVerifyR' (encodeUtf8 k) >>= sendResponse+ dispatch _ _ = notFound++newAccountR :: AuthRoute+newAccountR = PluginR "authHmacKeccak" ["newaccount"]++verifyR :: ByteString -> AuthRoute+verifyR k = PluginR "authHmacKeccak" ["verify", (decodeUtf8 k)]++resetPasswordR :: AuthRoute+resetPasswordR = PluginR "authHmacKeccak" ["resetpasswd"]++loginR :: AuthRoute+loginR = PluginR "authHmacKeccak" ["login"]++-- Login procedure.++loginWidget+ :: YesodHmacKeccak db master+ => (Route Auth -> Route master) -> WidgetT master IO ()+loginWidget tm = do+ render <- getUrlRenderParams+ toWidgetHead $ $(jsFile jsPath) render+ [whamlet|+<div .loginDiv>+ <form #loginform action=@{tm loginR} method="post">+ <div>+ <label for="username">_{MsgUser}:+ <input #username type="text" required>+ <div>+ <label for="password">_{MsgPassword}:+ <input #password type="password" required>+ <div>+ <button type="submit" #login>_{MsgLogin}+ <div #progress>+ <a href="@{tm newAccountR}">_{MsgRegister}+ <a href="@{tm resetPasswordR}">_{MsgForgotPassword}+ |]++postLoginR'+ :: ( YesodHmacKeccak db master+ , YesodAuth master+ )+ => HandlerT Auth (HandlerT master IO) RepJson+postLoginR' = do+ mr <- lift getMessageRender+ mUserName <- lookupPostParam "username"+ mHexToken <- lookupPostParam "token"+ mHexResponse <- lookupPostParam "response"+ case (mUserName, mHexToken, mHexResponse) of+ (Just userName, Nothing, Nothing) -> do+ tempUser <- lift $ runHmacDB $ loadUser userName+ case tempUser of+ Just u ->+ if userUserActive u+ then do+ let salt = userUserSalt u+ token <- liftIO makeRandomToken+ lift $ runHmacDB $ insertLoginToken (encodeUtf8 token) userName+ returnJson ["salt" .= toHex salt, "token" .= toHex (encodeUtf8 token)]+ else do+ returnJsonError (mr MsgUserNotActive)+ Nothing ->+ returnJsonError (mr MsgNoSuchUser)+ (Nothing, Just hexToken, Just hexResponse) -> do+ response <- do+ let tempToken = fromHex' $ T.unpack hexToken+ savedToken <- lift $ runHmacDB $ loadLoginToken tempToken+ case savedToken of+ Just token -> do+ queriedUser <- lift $ runHmacDB $ loadUser (tokenTokenUsername token)+ let salted = userUserSalted $ fromJust queriedUser+ hexSalted = toHex salted+ expected =+ hmacKeccak+ (encodeUtf8 $ toHex $ tokenTokenToken token)+ (encodeUtf8 hexSalted)+ if encodeUtf8 hexResponse == expected+ then do+ -- SUCCESS !!+ lift $ runHmacDB $ deleteToken token+ return $ Right $ fromJust queriedUser+ else+ return $ Left (mr MsgWrongPassword)+ Nothing ->+ return $ Left (mr MsgInvalidToken)+ case response of+ Left msg -> returnJsonError msg+ Right au -> do+ lift $ setCreds False $ Creds "authHmacKeccak" (userUserName au) []+ render <- lift getUrlRender+ m <- lift getYesod+ let u = render (loginDest m)+ returnJson ["welcome" .= u]+ _ ->+ returnJsonError (mr MsgProtocolError)++-- New account procedure++data NewAccountData = NewAccountData+ { naUsername :: Username+ , naEmail :: Text+ } deriving Show++newAccountForm+ :: ( YesodHmacKeccak db master+ , MonadHandler m+ , HandlerSite m ~ master+ ) => AForm m NewAccountData+newAccountForm = NewAccountData+ <$> areq (checkM checkValidUsername textField) userSettings Nothing+ <*> areq emailField emailSettings Nothing+ where+ userSettings = FieldSettings (SomeMessage MsgUsername) Nothing Nothing Nothing []+ emailSettings = FieldSettings (SomeMessage MsgEmail) Nothing Nothing Nothing []++newAccountWidget+ :: YesodHmacKeccak db master+ => (Route Auth -> Route master) -> WidgetT master IO ()+newAccountWidget tm = do+ render <- getUrlRenderParams+ toWidgetHead $ $(jsFile jsPath) render+ ((_, widget), enctype) <- liftHandlerT $ runFormPost $ renderDivs newAccountForm+ [whamlet|+<div .newaccount>+ <form method="post" enctype=#{enctype} action=@{tm newAccountR}>+ ^{widget}+ <input type=submit value=_{MsgRegister}>+ |]++getNewAccountR'+ :: YesodHmacKeccak db master+ => HandlerT Auth (HandlerT master IO) Html+getNewAccountR' = do+ tm <- getRouteToParent+ lift $ defaultLayout $ do+ setTitleI MsgRegisterLong+ newAccountWidget tm++postNewAccountR'+ :: YesodHmacKeccak db master+ => HandlerT Auth (HandlerT master IO) Html+postNewAccountR' = do+ tm <- getRouteToParent+ ((result, _), _) <- lift $ runFormPost $ renderDivs newAccountForm+ case result of+ FormMissing -> invalidArgs ["Form is missing"]+ FormFailure msg -> do+ setMessage $ toHtml $ T.concat msg+ redirect newAccountR+ FormSuccess d -> do+ lift $ setMessageI MsgActivationSent+ lift $ createNewAccount d tm+ redirect LoginR++createNewAccount+ :: YesodHmacKeccak db master+ => NewAccountData+ -> (Route Auth -> Route master)+ -> HandlerT master IO (UserAccount db)+createNewAccount nad@NewAccountData{..} tm = do+ muser <- runHmacDB $ loadUser naUsername+ case muser of+ Just _ -> do+ setMessageI $ MsgUsernameExists naUsername+ redirect $ tm newAccountR+ Nothing -> return ()+ token <- liftIO $ makeRandomToken+ salt <- liftIO $ makeRandomSalt+ enew <- runHmacDB $+ addNewUser naUsername naEmail (encodeUtf8 salt)+ _ <- runHmacDB $+ insertActivateToken (encodeUtf8 token) naUsername+ render <- getUrlRender+ sendVerifyEmail naUsername naEmail $ render $ tm $+ verifyR $ encodeUtf8 token+ new <- case enew of+ Left err -> do+ setMessage $ toHtml err+ redirect $ tm newAccountR+ Right x -> return x+ return new++-- verification procedure++data PWData = PWData+ { pw1 :: Text+ , pw2 :: Text+ }++passwordForm+ :: ( YesodHmacKeccak db master+ , MonadHandler m+ , HandlerSite m ~ master+ ) => AForm m PWData+passwordForm = PWData+ <$> areq textField pw1Settings Nothing+ <*> areq textField pw2Settings Nothing+ where+ pw1Settings = FieldSettings (SomeMessage MsgPassword1) Nothing Nothing Nothing []+ pw2Settings = FieldSettings (SomeMessage MsgPassword2) Nothing Nothing Nothing []++passwordWidget+ :: YesodHmacKeccak db master+ => (Route Auth -> Route master) -> ByteString -> ByteString -> WidgetT master IO ()+passwordWidget tm token hexSalt= do+ render <- getUrlRenderParams+ toWidgetHead $ $(jsFile jsPath) render+ [whamlet|+<div .password>+ <form #activateform method=post action=@{tm $ verifyR token}>+ <div .required>+ <label for="password1">_{MsgPassword1}:+ <input #password1 type="password" required>+ <div .required>+ <label for="password2">_{MsgPassword2}:+ <input #password2 type="password" required>+ <div #progress>+ <button #activate type="submit" data-token="#{BC.unpack token}" data-salt="#{BC.unpack hexSalt}">+ _{MsgActivate}+ |]++-- activateToken'+-- :: YesodHmacKeccak db master+-- => ByteString+-- -> HandlerT Auth (HandlerT master IO) (Maybe (TokenFoo db))+-- activateToken' = lift . runHmacDB . loadActivateToken++getVerifyR'+ :: YesodHmacKeccak db master+ => ByteString -> HandlerT Auth (HandlerT master IO) Html+getVerifyR' k = do+ mtoken <- lift $ runHmacDB $ loadActivateToken k+ case mtoken of+ Nothing -> do+ lift $ setMessageI MsgInvalidToken+ redirect LoginR+ Just token -> do+ muser <- lift $ runHmacDB $ loadUser $ tokenTokenUsername token+ case muser of+ Nothing -> do+ lift $ setMessageI MsgNoSuchUser+ redirect LoginR+ Just user -> do+ let hexSalt = toHex $ userUserSalt user+ tm <- getRouteToParent+ lift $ defaultLayout $ do+ setTitleI MsgSetPassword+ passwordWidget tm (tokenTokenToken token) (BC.pack $ T.unpack hexSalt)++postVerifyR'+ :: YesodHmacKeccak db master+ => ByteString -> HandlerT Auth (HandlerT master IO) RepJson+postVerifyR' k = do+ mtoken <- lift $ runHmacDB $ loadActivateToken k+ case mtoken of+ Nothing -> do+ lift $ setMessageI MsgInvalidToken+ redirect LoginR+ Just token -> do+ muser <- lift $ runHmacDB $ loadUser $ tokenTokenUsername token+ case muser of+ Nothing -> do+ lift $ setMessageI MsgNoSuchUser+ redirect LoginR+ Just user -> do+ msalted <- lookupPostParam "salted"+ case msalted of+ Nothing -> do+ lift $ setMessageI MsgProtocolError+ redirect LoginR+ Just salted' -> do+ let salted = fromHex' $ T.unpack salted'+ lift $ runHmacDB $ activateUser user salted+ lift $ runHmacDB $ deleteToken token+ lift $ setCreds False $ Creds "authHmacKeccak" (tokenTokenUsername token) []+ render <- lift getUrlRender+ m <- lift getYesod+ let u = render (loginDest m)+ returnJson ["welcome" .= u]++-- reactivation procedure (password reset)++reactivateForm+ :: ( YesodHmacKeccak db master+ , MonadHandler m+ , HandlerSite m ~ master+ ) => AForm m Username+reactivateForm = areq textField userSettings Nothing+ where+ userSettings = FieldSettings (SomeMessage MsgUsername) Nothing (Just "username") Nothing []++reactivateWidget+ :: YesodHmacKeccak db master+ => (Route Auth -> Route master) -> WidgetT master IO ()+reactivateWidget tm = do+ render <- getUrlRenderParams+ toWidgetHead $ $(jsFile jsPath) render+ ((_, widget), enctype) <- liftHandlerT $ runFormPost $ renderDivs reactivateForm+ [whamlet|+<div .reactivate>+ <form method="post" enctype=#{enctype} action=@{tm resetPasswordR}>+ ^{widget}+ <input type="submit" value=_{MsgSend}>+ |]++getReactivateR'+ :: YesodHmacKeccak db master+ => HandlerT Auth (HandlerT master IO) Html+getReactivateR' = do+ tm <- getRouteToParent+ lift $ defaultLayout $ do+ setTitleI MsgPasswordReset+ reactivateWidget tm++postReactivateR'+ :: YesodHmacKeccak db master+ => HandlerT Auth (HandlerT master IO) Html+postReactivateR' = do+ ((result, _), _) <- lift $ runFormPost $ renderDivs reactivateForm+ case result of+ FormMissing -> invalidArgs ["Form is missing"]+ FormFailure msg -> do+ lift $ setMessage $ toHtml $ T.concat msg+ redirect LoginR+ FormSuccess uname -> do+ muser <- lift $ runHmacDB $ loadUser uname+ case muser of+ Nothing -> do+ lift $ setMessageI MsgNoSuchUser+ redirect LoginR+ Just user -> do+ token <- liftIO makeRandomToken+ tm <- getRouteToParent+ lift $ runHmacDB $ insertActivateToken (encodeUtf8 token) uname+ render <- lift getUrlRender+ lift $ sendReactivateEmail uname (userUserEmail user) $+ render $ tm $ verifyR $ encodeUtf8 token+ lift $ setMessageI MsgActivationSent+ redirect LoginR++-- classes and foo++class UserCredentials u where+ userUserName :: u -> Username+ userUserSalt :: u -> ByteString+ userUserSalted :: u -> ByteString+ userUserEmail :: u -> Text+ userUserActive :: u -> Bool++class TokenData t where+ tokenTokenKind :: t -> Text+ tokenTokenUsername :: t -> Username+ tokenTokenToken :: t -> ByteString++class PersistUserCredentials u where+ userUsernameF :: EntityField u Username+ userUserSaltF :: EntityField u ByteString+ userUserSaltedF :: EntityField u ByteString+ userUserEmailF :: EntityField u Text+ userUserActiveF :: EntityField u Bool+ uniqueUsername :: Text -> P.Unique u++ userCreate+ :: Username -- ^ User name+ -> Text -- ^ Email+ -> ByteString -- ^ User salt+ -> u++class PersistToken t where+ tokenTokenTokenF :: EntityField t ByteString+ tokenTokenKindF :: EntityField t Text+ tokenTokenUsernameF :: EntityField t Username+ uniqueToken :: ByteString -> P.Unique t++ tokenCreate+ :: ByteString -- ^ actual Token+ -> Username -- ^ User name+ -> Text -- ^ Token kind+ -> t++class HmacDB m where+ type UserAccount m++ loadUser :: Username -> m (Maybe (UserAccount m))++ addNewUser :: Username -> Text -> ByteString -> m (Either Text (UserAccount m))++ activateUser :: (UserAccount m) -> ByteString -> m ()++ type TokenFoo m++ loadToken :: ByteString -> Text -> m (Maybe (TokenFoo m))++ insertToken :: ByteString -> Username -> Text -> m (Either Text (TokenFoo m))++ deleteToken :: (TokenFoo m) -> m ()++ insertLoginToken :: ByteString -> Username -> m (Either Text (TokenFoo m))+ insertLoginToken t u = insertToken t u "login"++ loadLoginToken :: ByteString -> m (Maybe (TokenFoo m))+ loadLoginToken = flip loadToken "login"++ insertActivateToken :: ByteString -> Username -> m (Either Text (TokenFoo m))+ insertActivateToken t u = insertToken t u "activate"++ loadActivateToken :: ByteString -> m (Maybe (TokenFoo m))+ loadActivateToken = flip loadToken "activate"++class HmacSendMail master where+ sendVerifyEmail+ :: Username -> Text -> Text -> HandlerT master IO ()++ sendReactivateEmail+ :: Username -> Text -> Text -> HandlerT master IO ()++class ( YesodAuth master+ , HmacSendMail master+ , HmacDB db+ , UserCredentials (UserAccount db)+ , TokenData (TokenFoo db)+ , RenderMessage master FormMessage+ ) => YesodHmacKeccak db master | master -> db where++ runHmacDB :: db a -> HandlerT master IO a++ checkValidUsername :: (MonadHandler m, HandlerSite m ~ master)+ => Username -> m (Either Text Username)+ checkValidUsername u+ | T.all C.isAlphaNum u = return $ Right u+ | otherwise = do+ mr <- getMessageRender+ return $ Left $ mr MsgInvalidUsername++ getNewAccountR :: HandlerT Auth (HandlerT master IO) Html+ getNewAccountR = getNewAccountR'++ postNewAccountR :: HandlerT Auth (HandlerT master IO) Html+ postNewAccountR = postNewAccountR'++ getReactivateR :: HandlerT Auth (HandlerT master IO) Html+ getReactivateR = getReactivateR'++ postReactivateR :: HandlerT Auth (HandlerT master IO) Html+ postReactivateR = postReactivateR'++ renderAccountMessage :: master -> [Text] -> AccountMsg -> Text+ renderAccountMessage _ _ = defaultAccountMsg++instance YesodHmacKeccak db master => RenderMessage master AccountMsg where+ renderMessage = renderAccountMessage++data PersistHmacFuncs master user token = PersistHmacFuncs+ { puGet :: Text -> HandlerT master IO (Maybe (Entity user))+ , puInsert :: Username -> user -> HandlerT master IO (Either Text (Entity user))+ , puUpdate :: Entity user -> [Update user] -> HandlerT master IO ()+ , ptGet :: ByteString -> Text -> HandlerT master IO (Maybe (Entity token))+ , ptInsert :: ByteString -> token -> HandlerT master IO (Either Text (Entity token))+ , ptUpdate :: Entity token -> [Update token] -> HandlerT master IO ()+ , ptDelete :: Entity token -> HandlerT master IO ()+ }++newtype HmacPersistDB master user token a+ = HmacPersistDB+ ( (ReaderT (PersistHmacFuncs master user token) (HandlerT master IO) a)+ ) deriving (Monad, MonadIO, Functor, Applicative)++instance (Yesod master, PersistUserCredentials user, PersistToken token)+ => HmacDB (HmacPersistDB master user token) where+ type UserAccount (HmacPersistDB master user token) = P.Entity user++ loadUser name = HmacPersistDB $ do+ f <- ask+ lift $ puGet f name++ addNewUser name email salt = HmacPersistDB $ do+ f <- ask+ lift $ puInsert f name $ userCreate name email salt++ activateUser user salted = HmacPersistDB $ do+ f <- ask+ lift $ puUpdate f user+ [ userUserSaltedF P.=. salted+ , userUserActiveF P.=. True+ ]++ type TokenFoo (HmacPersistDB master user token) = P.Entity token++ loadToken token kind = HmacPersistDB $ do+ f <- ask+ lift $ ptGet f token kind++ insertToken token uname kind = HmacPersistDB $ do+ f <- ask+ lift $ ptInsert f token $ tokenCreate token uname kind++ deleteToken t = HmacPersistDB $ do+ f <- ask+ lift $ ptDelete f t++makeRandomToken :: IO Text+makeRandomToken = (toHex . B.pack . take 16 . randoms) <$> newStdGen++makeRandomSalt :: IO Text+makeRandomSalt = (toHex . B.pack . take 8 . randoms) <$> newStdGen++returnJson :: Monad m => [Pair] -> m RepJson+returnJson = return . repJson . object++returnJsonError :: (ToJSON a, Monad m) => a -> m RepJson+returnJsonError = returnJson . (: []) . ("error" .=)++fromHex :: String -> BL.ByteString+fromHex = BL.pack . hexToWords+ where+ hexToWords (c:c':text) =+ let hex = [c, c']+ (word, _):_ = readHex hex+ in word : hexToWords text+ hexToWords _ = []++fromHex' :: String -> ByteString+fromHex' = B.concat . BL.toChunks . fromHex++toHex :: ByteString -> T.Text+toHex = T.pack . concatMap mapByte . B.unpack+ where+ mapByte = pad 2 '0' . flip showHex ""+ pad len padding s+ | length s < len = pad len padding $ padding:s+ | otherwise = s++hmacKeccak :: ByteString -> ByteString -> ByteString+hmacKeccak key msg = BC.pack $ show $ hmacGetDigest (hmac key msg :: HMAC Keccak_512)++runHmacPersistDB+ :: ( Yesod master+ , PersistQueryRead b+ , PersistToken token+ , YesodPersist master+ , P.PersistEntity user+ , PersistUserCredentials user+ , P.PersistEntity token+ , PersistToken token+ , b ~ YesodPersistBackend master+#if MIN_VERSION_persistent(2,1,0)+ , b ~ PersistEntityBackend user+ , b ~ PersistEntityBackend token+ , PersistUnique b+#else+ , PersistMonadBackend (b (HandlerT master IO)) ~ P.PersistEntityBackend user+ , PersistMonadBackend (b (HandlerT master IO)) ~ P.PersistEntityBackend token+ , P.PersistUnique (b (HandlerT master IO))+ , P.PersistQuery (b (HandlerT master IO))+#endif+#if MIN_VERSION_persistent(2,5,0)+ , b ~ BaseBackend b+#endif+ , YesodHmacKeccak db master+ , db ~ HmacPersistDB master user token+ ) => HmacPersistDB master user token a -> HandlerT master IO a+runHmacPersistDB (HmacPersistDB m) = runReaderT m funcs+ where funcs =+ PersistHmacFuncs+ { puGet = runDB . P.getBy . uniqueUsername+ , puInsert = \name u -> do { mentity <- runDB $ P.insertBy u;+ mr <- getMessageRender;+ case mentity of+ Left _ -> return $ Left $ mr $ MsgUsernameExists name;+ Right k -> return $ Right $ P.Entity k u;+ }+ , puUpdate = \(P.Entity key _) u -> runDB $ P.update key u+ , ptGet = \token kind -> runDB $ P.selectFirst+ [ tokenTokenKindF ==. kind+ , tokenTokenTokenF ==. token+ ] []+ , ptInsert = \name t -> do { mentity <- runDB $ P.insertBy t;+ mr <- getMessageRender;+ case mentity of+ Left _ -> return $ Left $ mr $ MsgInvalidToken;+ Right k -> return $ Right $ P.Entity k t;+ }+ , ptUpdate = \(P.Entity key _) t -> runDB $ P.update key t+ , ptDelete = \(P.Entity key _) -> runDB $ P.delete key+ }
+ hssrc/Yesod/Auth/Import.hs view
@@ -0,0 +1,22 @@+module Yesod.Auth.Import+ ( module Import+ ) where++import Data.Text as Import (Text)+import Data.Text.Encoding as Import+import Data.Maybe as Import+import Data.Aeson as Import hiding (returnJson)+import Data.Aeson.Types as Import++import Data.ByteString as Import (ByteString)++import Database.Persist as Import hiding (count)++import Crypto.MAC.HMAC as Import hiding (update)+import Crypto.Hash.Algorithms as Import (Keccak_512)++import Control.Monad.Reader as Import++import Yesod.Core as Import hiding (returnJson)+import Yesod.Form as Import+import Yesod.Auth as Import
+ hssrc/Yesod/Auth/JsPath.hs view
@@ -0,0 +1,8 @@+module Yesod.Auth.JsPath where++import System.IO.Unsafe (unsafePerformIO)++import Paths_yesod_auth_hmac_keccak (getDataFileName)++jsPath :: FilePath+jsPath = unsafePerformIO (getDataFileName "static/js/auth.js")
+ hssrc/Yesod/Auth/Message.hs view
@@ -0,0 +1,57 @@+{-# LANGUAGE OverloadedStrings #-}++module Yesod.Auth.Message where++import qualified Data.Text as T++data AccountMsg+ = MsgUser+ | MsgPassword+ | MsgLogin+ | MsgRegister+ | MsgForgotPassword+ | MsgNoSuchUser+ | MsgWrongPassword+ | MsgInvalidToken+ | MsgInvalidUsername+ | MsgProtocolError+ | MsgUsername+ | MsgEmail+ | MsgRegisterLong+ | MsgPassword1+ | MsgPassword2+ | MsgActivate+ | MsgSetPassword+ | MsgSend+ | MsgPasswordReset+ | MsgActivationSent+ | MsgUsernameExists T.Text+ | MsgUserNotActive++defaultAccountMsg :: AccountMsg -> T.Text+defaultAccountMsg = englishAccountMsg++englishAccountMsg :: AccountMsg -> T.Text+englishAccountMsg MsgUser = "User"+englishAccountMsg MsgPassword = "Password"+englishAccountMsg MsgLogin = "Login"+englishAccountMsg MsgRegister = "Register"+englishAccountMsg MsgForgotPassword = "Forgot password?"+englishAccountMsg MsgNoSuchUser = "No such user"+englishAccountMsg MsgWrongPassword = "Wrong password"+englishAccountMsg MsgInvalidToken = "Invalid token"+englishAccountMsg MsgInvalidUsername = "Invalid username"+englishAccountMsg MsgProtocolError = "Protocol error"+englishAccountMsg MsgUsername = "Username"+englishAccountMsg MsgEmail = "Email"+englishAccountMsg MsgRegisterLong = "Register a new account"+englishAccountMsg MsgPassword1 = "Enter new password"+englishAccountMsg MsgPassword2 = "Repeat new password"+englishAccountMsg MsgActivate = "Activate"+englishAccountMsg MsgSetPassword = "Set password"+englishAccountMsg MsgSend = "Send"+englishAccountMsg MsgPasswordReset = "Reset password"+englishAccountMsg MsgActivationSent = "You will receive your Activation in your email"+englishAccountMsg (MsgUsernameExists u) = T.concat+ ["The user ", u, " already exists. Please choose an alternate username."]+englishAccountMsg MsgUserNotActive = "Please activate your account before logging in"
+ hssrc/Yesod/Auth/Types.hs view
@@ -0,0 +1,5 @@+module Yesod.Auth.Types where++import Yesod.Auth.Import++type Username = Text
+ src/Activate.purs view
@@ -0,0 +1,79 @@+module Activate where++import Prelude (Unit, bind, not, pure, show, unit, ($), (&&), (<>), (=<<), (==), discard)+import Control.Monad.Aff (runAff)+import Control.Monad.Eff (Eff)+import Control.Monad.Eff.Console (CONSOLE, log)+import Control.Monad.Eff.JQuery (JQuery, JQueryEvent, display, hide, getValue, on, preventDefault, ready, select)++import DOM (DOM)++import Data.Function.Uncurried (runFn2)+import Data.Maybe (Maybe(..), fromJust, isNothing)+import Data.Tuple (Tuple(..))++import Network.HTTP.Affjax (AJAX, post)++import Data.FormURLEncoded as UE++import Partial.Unsafe (unsafePartial)++import Common (Elem(..), fail, fromForeign, fromHex, fromUtf8, getAttr, hmacSha3, progress, welcome)++-- main :: forall e. Eff (console :: CONSOLE | e) Unit+-- main = do+-- log "Hello sailor!"++-- main :: forall eff. Eff ( ajax :: AJAX+-- , dom :: DOM+-- , console :: CONSOLE+-- | eff+-- ) Unit+-- main =+-- ready $ do+-- log "activating"+-- display =<< select ".js-hidden"+-- hide =<< select ".noscript"+-- activate <- select "#activate"+-- on "click" (onActivateClick activate) activate++onActivateClick+ :: forall eff. JQuery+ -> JQueryEvent+ -> JQuery+ -> Eff (dom :: DOM+ , console :: CONSOLE+ , ajax :: AJAX+ | eff+ ) Unit+onActivateClick activate ev _ = unsafePartial $ do+ preventDefault ev+ token <- getAttr "data-token" activate+ -- log $ "token: " <> token+ salt <- getAttr "data-salt" activate+ -- log $ "salt: " <> salt+ fpassword1 <- getValue =<< select "#password1"+ fpassword2 <- getValue =<< select "#password2"+ formAction <- getAttr "action" =<< select "#activateform"+ log formAction+ let password1 = fromForeign fpassword1+ password2 = fromForeign fpassword2+ if not (isNothing password1 && isNothing password2)+ then+ if password1 == password2+ then do+ progress "Salting password"+ -- log $ fromJust password1 <> " " <> salt+ let salted = runFn2 hmacSha3 (fromUtf8 $ fromJust password1) (fromHex salt)+ -- log salted+ progress "Requesting account activation..."+ let dat = UE.fromArray [ Tuple "salted" (Just salted) ]+ _ <- runAff+ (\e -> fail Activate $ show e)+ (\x -> welcome x.response Activate)+ $ post formAction dat+ pure unit+ else+ fail Activate "Passwords must match"+ else+ fail Activate "Passwords error"
+ src/Common.js view
@@ -0,0 +1,37 @@+"use strict";++var CryptoJS = require('crypto-js');++exports.hmacSha3 = function(msg, key) {+ var hmac = CryptoJS.HmacSHA3(msg, key);+ //console.log("bla");+ //console.log(hmac.toString());+ //console.log(CryptoJS.enc.Utf8.stringify(hmac));+ return hmac.toString();+}++exports.setLocation = function(newLoc) {+ window.location = newLoc;+ return null;+}++exports.getAttr = function(attr) {+ return function(ob) {+ return function() {+ return ob.attr(attr);+ };+ };+};++exports.toHex = function(str) {+ var repr = parseInt(str, 16);+ return repr.toString(16);+}++exports.fromHex = function(str) {+ return CryptoJS.enc.Hex.parse(str);+}++exports.fromUtf8 = function(str) {+ return CryptoJS.enc.Utf8.parse(str);+}
+ src/Common.purs view
@@ -0,0 +1,97 @@+module Common where++import Prelude (Unit, bind, pure, ($), (<$>), (=<<), discard)+import Control.Monad.Eff (Eff)+import Control.Monad.Eff.JQuery (JQuery, display, select, setProp, setText)+import Control.Monad.Except (runExcept)+import DOM (DOM)+import Data.Function.Uncurried (Fn2)+import Data.Maybe (Maybe(..))+import Data.Either (Either(..), either)+import Data.Foreign as F+import Data.Argonaut (Json) as A+import Data.Argonaut.Decode++data Elem+ = Login+ | Activate++welcome :: forall eff. A.Json -> Elem -> Eff (dom :: DOM | eff) Unit+welcome j elem = do+ let eitherWelcome = decodeJson j+ case eitherWelcome of+ Left _ -> do+ let eitherErr = decodeJson j+ either (fail elem) (\(Err e) -> fail elem e.err) eitherErr+ Right (Welcome welc) -> do+ progress "Welcome!"+ setLocation welc.link++progress :: forall eff. String -> Eff (dom :: DOM | eff) Unit+progress s = do+ setText s =<< select "#progress"++fail :: forall eff. Elem -> String -> Eff (dom :: DOM | eff) Unit+fail Login s = do+ progress s+ _ <- setProp "disabled" false <$> select ".login input"+ display =<< select "#login"+fail Activate s = do+ progress s+ _ <- setProp "disabled" false <$> select ".activate input"+ display =<< select "#activate"++data Challenge = Challenge+ { salt :: String+ , token :: String+ }++instance decodeJsonChallenge :: DecodeJson Challenge where+ decodeJson j = do+ obj <- decodeJson j+ salt <- obj .? "salt"+ token <- obj .? "token"+ pure $ Challenge { salt, token }++data Welcome = Welcome+ { link :: String+ }++instance decodeJsonWelcome :: DecodeJson Welcome where+ decodeJson j = do+ obj <- decodeJson j+ link <- obj .? "welcome"+ pure $ Welcome { link }++data Err = Err+ { err :: String+ }++instance decodeJsonErr :: DecodeJson Err where+ decodeJson j = do+ obj <- decodeJson j+ error <- obj .? "error"+ pure $ Err { err: error }++fromForeign :: F.Foreign -> Maybe String+fromForeign f = case runExcept (F.readString f) of+ Left e -> Nothing+ Right s -> Just s++foreign import hmacSha3 :: Fn2 WordArray WordArray String++foreign import setLocation :: forall eff. String -> Eff (dom :: DOM | eff) Unit++foreign import getAttr+ :: forall eff+ . String+ -> JQuery+ -> Eff (dom :: DOM | eff) String++foreign import toHex :: String -> String++foreign import fromHex :: String -> WordArray++foreign import fromUtf8 :: String -> WordArray++foreign import data WordArray :: Type
+ src/Login.purs view
@@ -0,0 +1,104 @@+module Login where++import Prelude (Unit, bind, not, pure, show, unit, ($), (&&), (<$>), (=<<), discard)+import Control.Monad.Aff (runAff)+import Control.Monad.Eff (Eff)+import Control.Monad.Eff.Console (CONSOLE, log)+import Control.Monad.Eff.JQuery (JQuery, JQueryEvent, display, getValue, hide, on, preventDefault, ready, select, setProp)++import DOM (DOM)++import Data.Function.Uncurried (runFn2)+import Data.Maybe (Maybe(..), fromJust, isNothing)+import Data.Either (Either(..), either)+import Data.Tuple (Tuple(..))++import Data.Argonaut as A+import Data.Argonaut.Decode (decodeJson)++import Network.HTTP.Affjax (AJAX, post)++import Data.FormURLEncoded as UE++import Partial.Unsafe (unsafePartial)++import Common (Challenge(..), Elem(..), Err(..), fail, fromForeign, fromHex, fromUtf8, hmacSha3, progress, welcome, getAttr)++-- main :: forall e. Eff (console :: CONSOLE | e) Unit+-- main = do+-- log "Hello sailor!"++-- main :: forall eff. Eff ( ajax :: AJAX+-- , dom :: DOM+-- , console :: CONSOLE+-- | eff+-- ) Unit+-- main =+-- ready $ do+-- log "logging in"+-- display =<< select ".js-hidden"+-- hide =<< select ".noscript"+-- login <- select "#login"+-- on "click" (onLoginClick login) login++onLoginClick+ :: forall eff. JQuery+ -> JQueryEvent+ -> JQuery+ -> Eff ( dom :: DOM+ , console :: CONSOLE+ , ajax :: AJAX+ | eff+ ) Unit+onLoginClick login ev x = unsafePartial $ do+ log "click!"+ preventDefault ev+ hide login+ _ <- setProp "disabled" true <$> select ".login input"+ fusername <- getValue =<< select "#username"+ fpassword <- getValue =<< select "#password"+ formAction <- getAttr "action" =<< select "#loginform"+ log formAction+ let username = fromForeign fusername+ password = fromForeign fpassword+ if not (isNothing username && isNothing password)+ then do+ progress "Obtaining Challenge..."+ let data1 = UE.fromArray $ [ Tuple "username" username ]+ _ <- runAff+ (\e -> fail Login $ show e)+ (\y -> resp1Success (fromJust password) y.response formAction)+ $ post formAction data1+ log "success so far"+ else+ log "error"++resp1Success :: forall eff. String+ -> A.Json+ -> String+ -> Eff ( dom :: DOM+ , console :: CONSOLE+ , ajax :: AJAX+ | eff+ ) Unit+resp1Success pass j loc = do+ log $ show j+ let eitherChallenge = decodeJson j+ case eitherChallenge of+ Left _ -> do+ let eitherErr = decodeJson j+ either (fail Login) (\(Err e) -> fail Login e.err) eitherErr+ Right (Challenge challenge) -> do+ progress "HMAC 1"+ let salted = runFn2 hmacSha3 (fromUtf8 pass) (fromHex challenge.salt)+ -- log $ "salted: " <> salted+ progress "HMAC 2"+ let response = runFn2 hmacSha3 (fromUtf8 salted) (fromUtf8 challenge.token)+ -- log $ "resp: " <> response+ progress "sending response"+ let data2 = UE.fromArray $ [ Tuple "token" (Just challenge.token), Tuple "response" (Just response) ]+ _ <- runAff+ (\e -> fail Login $ show e)+ (\x -> welcome x.response Login)+ $ post loc data2+ pure unit
+ src/Main.purs view
@@ -0,0 +1,30 @@+module Main where++import Prelude (bind, ($), (=<<), discard, Unit)+import Control.Monad.Eff (Eff)+import Control.Monad.Eff.Console (CONSOLE, log)+import Control.Monad.Eff.JQuery (JQuery, display, hide, on, ready, select)++import DOM (DOM)+import Network.HTTP.Affjax (AJAX)++import Login (onLoginClick)+import Activate (onActivateClick)++main :: forall eff.+ Eff+ ( dom :: DOM+ , ajax :: AJAX+ , console :: CONSOLE+ | eff+ )+ Unit+main =+ ready $ do+ log "let's go"+ display =<< select ".js-hidden"+ hide =<< select ".noscript"+ activate <- select "#activate"+ login <- select "#login"+ on "click" (onActivateClick activate) activate+ on "click" (onLoginClick activate) login
+ static/js/auth.js view
@@ -0,0 +1,31966 @@+(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function () {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var BlockCipher = C_lib.BlockCipher;+ var C_algo = C.algo;++ // Lookup tables+ var SBOX = [];+ var INV_SBOX = [];+ var SUB_MIX_0 = [];+ var SUB_MIX_1 = [];+ var SUB_MIX_2 = [];+ var SUB_MIX_3 = [];+ var INV_SUB_MIX_0 = [];+ var INV_SUB_MIX_1 = [];+ var INV_SUB_MIX_2 = [];+ var INV_SUB_MIX_3 = [];++ // Compute lookup tables+ (function () {+ // Compute double table+ var d = [];+ for (var i = 0; i < 256; i++) {+ if (i < 128) {+ d[i] = i << 1;+ } else {+ d[i] = (i << 1) ^ 0x11b;+ }+ }++ // Walk GF(2^8)+ var x = 0;+ var xi = 0;+ for (var i = 0; i < 256; i++) {+ // Compute sbox+ var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);+ sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;+ SBOX[x] = sx;+ INV_SBOX[sx] = x;++ // Compute multiplication+ var x2 = d[x];+ var x4 = d[x2];+ var x8 = d[x4];++ // Compute sub bytes, mix columns tables+ var t = (d[sx] * 0x101) ^ (sx * 0x1010100);+ SUB_MIX_0[x] = (t << 24) | (t >>> 8);+ SUB_MIX_1[x] = (t << 16) | (t >>> 16);+ SUB_MIX_2[x] = (t << 8) | (t >>> 24);+ SUB_MIX_3[x] = t;++ // Compute inv sub bytes, inv mix columns tables+ var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);+ INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8);+ INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16);+ INV_SUB_MIX_2[sx] = (t << 8) | (t >>> 24);+ INV_SUB_MIX_3[sx] = t;++ // Compute next counter+ if (!x) {+ x = xi = 1;+ } else {+ x = x2 ^ d[d[d[x8 ^ x2]]];+ xi ^= d[d[xi]];+ }+ }+ }());++ // Precomputed Rcon lookup+ var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];++ /**+ * AES block cipher algorithm.+ */+ var AES = C_algo.AES = BlockCipher.extend({+ _doReset: function () {+ // Skip reset of nRounds has been set before and key did not change+ if (this._nRounds && this._keyPriorReset === this._key) {+ return;+ }++ // Shortcuts+ var key = this._keyPriorReset = this._key;+ var keyWords = key.words;+ var keySize = key.sigBytes / 4;++ // Compute number of rounds+ var nRounds = this._nRounds = keySize + 6;++ // Compute number of key schedule rows+ var ksRows = (nRounds + 1) * 4;++ // Compute key schedule+ var keySchedule = this._keySchedule = [];+ for (var ksRow = 0; ksRow < ksRows; ksRow++) {+ if (ksRow < keySize) {+ keySchedule[ksRow] = keyWords[ksRow];+ } else {+ var t = keySchedule[ksRow - 1];++ if (!(ksRow % keySize)) {+ // Rot word+ t = (t << 8) | (t >>> 24);++ // Sub word+ t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];++ // Mix Rcon+ t ^= RCON[(ksRow / keySize) | 0] << 24;+ } else if (keySize > 6 && ksRow % keySize == 4) {+ // Sub word+ t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];+ }++ keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;+ }+ }++ // Compute inv key schedule+ var invKeySchedule = this._invKeySchedule = [];+ for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {+ var ksRow = ksRows - invKsRow;++ if (invKsRow % 4) {+ var t = keySchedule[ksRow];+ } else {+ var t = keySchedule[ksRow - 4];+ }++ if (invKsRow < 4 || ksRow <= 4) {+ invKeySchedule[invKsRow] = t;+ } else {+ invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^+ INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];+ }+ }+ },++ encryptBlock: function (M, offset) {+ this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);+ },++ decryptBlock: function (M, offset) {+ // Swap 2nd and 4th rows+ var t = M[offset + 1];+ M[offset + 1] = M[offset + 3];+ M[offset + 3] = t;++ this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);++ // Inv swap 2nd and 4th rows+ var t = M[offset + 1];+ M[offset + 1] = M[offset + 3];+ M[offset + 3] = t;+ },++ _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {+ // Shortcut+ var nRounds = this._nRounds;++ // Get input, add round key+ var s0 = M[offset] ^ keySchedule[0];+ var s1 = M[offset + 1] ^ keySchedule[1];+ var s2 = M[offset + 2] ^ keySchedule[2];+ var s3 = M[offset + 3] ^ keySchedule[3];++ // Key schedule row counter+ var ksRow = 4;++ // Rounds+ for (var round = 1; round < nRounds; round++) {+ // Shift rows, sub bytes, mix columns, add round key+ var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++];+ var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++];+ var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++];+ var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++];++ // Update state+ s0 = t0;+ s1 = t1;+ s2 = t2;+ s3 = t3;+ }++ // Shift rows, sub bytes, add round key+ var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];+ var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];+ var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];+ var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];++ // Set output+ M[offset] = t0;+ M[offset + 1] = t1;+ M[offset + 2] = t2;+ M[offset + 3] = t3;+ },++ keySize: 256/32+ });++ /**+ * Shortcut functions to the cipher's object interface.+ *+ * @example+ *+ * var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);+ * var plaintext = CryptoJS.AES.decrypt(ciphertext, key, cfg);+ */+ C.AES = BlockCipher._createHelper(AES);+ }());+++ return CryptoJS.AES;++}));+},{"./cipher-core":2,"./core":3,"./enc-base64":4,"./evpkdf":6,"./md5":11}],2:[function(require,module,exports){+;(function (root, factory) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ /**+ * Cipher core components.+ */+ CryptoJS.lib.Cipher || (function (undefined) {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var Base = C_lib.Base;+ var WordArray = C_lib.WordArray;+ var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;+ var C_enc = C.enc;+ var Utf8 = C_enc.Utf8;+ var Base64 = C_enc.Base64;+ var C_algo = C.algo;+ var EvpKDF = C_algo.EvpKDF;++ /**+ * Abstract base cipher template.+ *+ * @property {number} keySize This cipher's key size. Default: 4 (128 bits)+ * @property {number} ivSize This cipher's IV size. Default: 4 (128 bits)+ * @property {number} _ENC_XFORM_MODE A constant representing encryption mode.+ * @property {number} _DEC_XFORM_MODE A constant representing decryption mode.+ */+ var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({+ /**+ * Configuration options.+ *+ * @property {WordArray} iv The IV to use for this operation.+ */+ cfg: Base.extend(),++ /**+ * Creates this cipher in encryption mode.+ *+ * @param {WordArray} key The key.+ * @param {Object} cfg (Optional) The configuration options to use for this operation.+ *+ * @return {Cipher} A cipher instance.+ *+ * @static+ *+ * @example+ *+ * var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray });+ */+ createEncryptor: function (key, cfg) {+ return this.create(this._ENC_XFORM_MODE, key, cfg);+ },++ /**+ * Creates this cipher in decryption mode.+ *+ * @param {WordArray} key The key.+ * @param {Object} cfg (Optional) The configuration options to use for this operation.+ *+ * @return {Cipher} A cipher instance.+ *+ * @static+ *+ * @example+ *+ * var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray });+ */+ createDecryptor: function (key, cfg) {+ return this.create(this._DEC_XFORM_MODE, key, cfg);+ },++ /**+ * Initializes a newly created cipher.+ *+ * @param {number} xformMode Either the encryption or decryption transormation mode constant.+ * @param {WordArray} key The key.+ * @param {Object} cfg (Optional) The configuration options to use for this operation.+ *+ * @example+ *+ * var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });+ */+ init: function (xformMode, key, cfg) {+ // Apply config defaults+ this.cfg = this.cfg.extend(cfg);++ // Store transform mode and key+ this._xformMode = xformMode;+ this._key = key;++ // Set initial values+ this.reset();+ },++ /**+ * Resets this cipher to its initial state.+ *+ * @example+ *+ * cipher.reset();+ */+ reset: function () {+ // Reset data buffer+ BufferedBlockAlgorithm.reset.call(this);++ // Perform concrete-cipher logic+ this._doReset();+ },++ /**+ * Adds data to be encrypted or decrypted.+ *+ * @param {WordArray|string} dataUpdate The data to encrypt or decrypt.+ *+ * @return {WordArray} The data after processing.+ *+ * @example+ *+ * var encrypted = cipher.process('data');+ * var encrypted = cipher.process(wordArray);+ */+ process: function (dataUpdate) {+ // Append+ this._append(dataUpdate);++ // Process available blocks+ return this._process();+ },++ /**+ * Finalizes the encryption or decryption process.+ * Note that the finalize operation is effectively a destructive, read-once operation.+ *+ * @param {WordArray|string} dataUpdate The final data to encrypt or decrypt.+ *+ * @return {WordArray} The data after final processing.+ *+ * @example+ *+ * var encrypted = cipher.finalize();+ * var encrypted = cipher.finalize('data');+ * var encrypted = cipher.finalize(wordArray);+ */+ finalize: function (dataUpdate) {+ // Final data update+ if (dataUpdate) {+ this._append(dataUpdate);+ }++ // Perform concrete-cipher logic+ var finalProcessedData = this._doFinalize();++ return finalProcessedData;+ },++ keySize: 128/32,++ ivSize: 128/32,++ _ENC_XFORM_MODE: 1,++ _DEC_XFORM_MODE: 2,++ /**+ * Creates shortcut functions to a cipher's object interface.+ *+ * @param {Cipher} cipher The cipher to create a helper for.+ *+ * @return {Object} An object with encrypt and decrypt shortcut functions.+ *+ * @static+ *+ * @example+ *+ * var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES);+ */+ _createHelper: (function () {+ function selectCipherStrategy(key) {+ if (typeof key == 'string') {+ return PasswordBasedCipher;+ } else {+ return SerializableCipher;+ }+ }++ return function (cipher) {+ return {+ encrypt: function (message, key, cfg) {+ return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);+ },++ decrypt: function (ciphertext, key, cfg) {+ return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);+ }+ };+ };+ }())+ });++ /**+ * Abstract base stream cipher template.+ *+ * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 1 (32 bits)+ */+ var StreamCipher = C_lib.StreamCipher = Cipher.extend({+ _doFinalize: function () {+ // Process partial blocks+ var finalProcessedBlocks = this._process(!!'flush');++ return finalProcessedBlocks;+ },++ blockSize: 1+ });++ /**+ * Mode namespace.+ */+ var C_mode = C.mode = {};++ /**+ * Abstract base block cipher mode template.+ */+ var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({+ /**+ * Creates this mode for encryption.+ *+ * @param {Cipher} cipher A block cipher instance.+ * @param {Array} iv The IV words.+ *+ * @static+ *+ * @example+ *+ * var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words);+ */+ createEncryptor: function (cipher, iv) {+ return this.Encryptor.create(cipher, iv);+ },++ /**+ * Creates this mode for decryption.+ *+ * @param {Cipher} cipher A block cipher instance.+ * @param {Array} iv The IV words.+ *+ * @static+ *+ * @example+ *+ * var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words);+ */+ createDecryptor: function (cipher, iv) {+ return this.Decryptor.create(cipher, iv);+ },++ /**+ * Initializes a newly created mode.+ *+ * @param {Cipher} cipher A block cipher instance.+ * @param {Array} iv The IV words.+ *+ * @example+ *+ * var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words);+ */+ init: function (cipher, iv) {+ this._cipher = cipher;+ this._iv = iv;+ }+ });++ /**+ * Cipher Block Chaining mode.+ */+ var CBC = C_mode.CBC = (function () {+ /**+ * Abstract base CBC mode.+ */+ var CBC = BlockCipherMode.extend();++ /**+ * CBC encryptor.+ */+ CBC.Encryptor = CBC.extend({+ /**+ * Processes the data block at offset.+ *+ * @param {Array} words The data words to operate on.+ * @param {number} offset The offset where the block starts.+ *+ * @example+ *+ * mode.processBlock(data.words, offset);+ */+ processBlock: function (words, offset) {+ // Shortcuts+ var cipher = this._cipher;+ var blockSize = cipher.blockSize;++ // XOR and encrypt+ xorBlock.call(this, words, offset, blockSize);+ cipher.encryptBlock(words, offset);++ // Remember this block to use with next block+ this._prevBlock = words.slice(offset, offset + blockSize);+ }+ });++ /**+ * CBC decryptor.+ */+ CBC.Decryptor = CBC.extend({+ /**+ * Processes the data block at offset.+ *+ * @param {Array} words The data words to operate on.+ * @param {number} offset The offset where the block starts.+ *+ * @example+ *+ * mode.processBlock(data.words, offset);+ */+ processBlock: function (words, offset) {+ // Shortcuts+ var cipher = this._cipher;+ var blockSize = cipher.blockSize;++ // Remember this block to use with next block+ var thisBlock = words.slice(offset, offset + blockSize);++ // Decrypt and XOR+ cipher.decryptBlock(words, offset);+ xorBlock.call(this, words, offset, blockSize);++ // This block becomes the previous block+ this._prevBlock = thisBlock;+ }+ });++ function xorBlock(words, offset, blockSize) {+ // Shortcut+ var iv = this._iv;++ // Choose mixing block+ if (iv) {+ var block = iv;++ // Remove IV for subsequent blocks+ this._iv = undefined;+ } else {+ var block = this._prevBlock;+ }++ // XOR blocks+ for (var i = 0; i < blockSize; i++) {+ words[offset + i] ^= block[i];+ }+ }++ return CBC;+ }());++ /**+ * Padding namespace.+ */+ var C_pad = C.pad = {};++ /**+ * PKCS #5/7 padding strategy.+ */+ var Pkcs7 = C_pad.Pkcs7 = {+ /**+ * Pads data using the algorithm defined in PKCS #5/7.+ *+ * @param {WordArray} data The data to pad.+ * @param {number} blockSize The multiple that the data should be padded to.+ *+ * @static+ *+ * @example+ *+ * CryptoJS.pad.Pkcs7.pad(wordArray, 4);+ */+ pad: function (data, blockSize) {+ // Shortcut+ var blockSizeBytes = blockSize * 4;++ // Count padding bytes+ var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;++ // Create padding word+ var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes;++ // Create padding+ var paddingWords = [];+ for (var i = 0; i < nPaddingBytes; i += 4) {+ paddingWords.push(paddingWord);+ }+ var padding = WordArray.create(paddingWords, nPaddingBytes);++ // Add padding+ data.concat(padding);+ },++ /**+ * Unpads data that had been padded using the algorithm defined in PKCS #5/7.+ *+ * @param {WordArray} data The data to unpad.+ *+ * @static+ *+ * @example+ *+ * CryptoJS.pad.Pkcs7.unpad(wordArray);+ */+ unpad: function (data) {+ // Get number of padding bytes from last byte+ var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;++ // Remove padding+ data.sigBytes -= nPaddingBytes;+ }+ };++ /**+ * Abstract base block cipher template.+ *+ * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 4 (128 bits)+ */+ var BlockCipher = C_lib.BlockCipher = Cipher.extend({+ /**+ * Configuration options.+ *+ * @property {Mode} mode The block mode to use. Default: CBC+ * @property {Padding} padding The padding strategy to use. Default: Pkcs7+ */+ cfg: Cipher.cfg.extend({+ mode: CBC,+ padding: Pkcs7+ }),++ reset: function () {+ // Reset cipher+ Cipher.reset.call(this);++ // Shortcuts+ var cfg = this.cfg;+ var iv = cfg.iv;+ var mode = cfg.mode;++ // Reset block mode+ if (this._xformMode == this._ENC_XFORM_MODE) {+ var modeCreator = mode.createEncryptor;+ } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {+ var modeCreator = mode.createDecryptor;++ // Keep at least one block in the buffer for unpadding+ this._minBufferSize = 1;+ }+ this._mode = modeCreator.call(mode, this, iv && iv.words);+ },++ _doProcessBlock: function (words, offset) {+ this._mode.processBlock(words, offset);+ },++ _doFinalize: function () {+ // Shortcut+ var padding = this.cfg.padding;++ // Finalize+ if (this._xformMode == this._ENC_XFORM_MODE) {+ // Pad data+ padding.pad(this._data, this.blockSize);++ // Process final blocks+ var finalProcessedBlocks = this._process(!!'flush');+ } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {+ // Process final blocks+ var finalProcessedBlocks = this._process(!!'flush');++ // Unpad data+ padding.unpad(finalProcessedBlocks);+ }++ return finalProcessedBlocks;+ },++ blockSize: 128/32+ });++ /**+ * A collection of cipher parameters.+ *+ * @property {WordArray} ciphertext The raw ciphertext.+ * @property {WordArray} key The key to this ciphertext.+ * @property {WordArray} iv The IV used in the ciphering operation.+ * @property {WordArray} salt The salt used with a key derivation function.+ * @property {Cipher} algorithm The cipher algorithm.+ * @property {Mode} mode The block mode used in the ciphering operation.+ * @property {Padding} padding The padding scheme used in the ciphering operation.+ * @property {number} blockSize The block size of the cipher.+ * @property {Format} formatter The default formatting strategy to convert this cipher params object to a string.+ */+ var CipherParams = C_lib.CipherParams = Base.extend({+ /**+ * Initializes a newly created cipher params object.+ *+ * @param {Object} cipherParams An object with any of the possible cipher parameters.+ *+ * @example+ *+ * var cipherParams = CryptoJS.lib.CipherParams.create({+ * ciphertext: ciphertextWordArray,+ * key: keyWordArray,+ * iv: ivWordArray,+ * salt: saltWordArray,+ * algorithm: CryptoJS.algo.AES,+ * mode: CryptoJS.mode.CBC,+ * padding: CryptoJS.pad.PKCS7,+ * blockSize: 4,+ * formatter: CryptoJS.format.OpenSSL+ * });+ */+ init: function (cipherParams) {+ this.mixIn(cipherParams);+ },++ /**+ * Converts this cipher params object to a string.+ *+ * @param {Format} formatter (Optional) The formatting strategy to use.+ *+ * @return {string} The stringified cipher params.+ *+ * @throws Error If neither the formatter nor the default formatter is set.+ *+ * @example+ *+ * var string = cipherParams + '';+ * var string = cipherParams.toString();+ * var string = cipherParams.toString(CryptoJS.format.OpenSSL);+ */+ toString: function (formatter) {+ return (formatter || this.formatter).stringify(this);+ }+ });++ /**+ * Format namespace.+ */+ var C_format = C.format = {};++ /**+ * OpenSSL formatting strategy.+ */+ var OpenSSLFormatter = C_format.OpenSSL = {+ /**+ * Converts a cipher params object to an OpenSSL-compatible string.+ *+ * @param {CipherParams} cipherParams The cipher params object.+ *+ * @return {string} The OpenSSL-compatible string.+ *+ * @static+ *+ * @example+ *+ * var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams);+ */+ stringify: function (cipherParams) {+ // Shortcuts+ var ciphertext = cipherParams.ciphertext;+ var salt = cipherParams.salt;++ // Format+ if (salt) {+ var wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext);+ } else {+ var wordArray = ciphertext;+ }++ return wordArray.toString(Base64);+ },++ /**+ * Converts an OpenSSL-compatible string to a cipher params object.+ *+ * @param {string} openSSLStr The OpenSSL-compatible string.+ *+ * @return {CipherParams} The cipher params object.+ *+ * @static+ *+ * @example+ *+ * var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString);+ */+ parse: function (openSSLStr) {+ // Parse base64+ var ciphertext = Base64.parse(openSSLStr);++ // Shortcut+ var ciphertextWords = ciphertext.words;++ // Test for salt+ if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) {+ // Extract salt+ var salt = WordArray.create(ciphertextWords.slice(2, 4));++ // Remove salt from ciphertext+ ciphertextWords.splice(0, 4);+ ciphertext.sigBytes -= 16;+ }++ return CipherParams.create({ ciphertext: ciphertext, salt: salt });+ }+ };++ /**+ * A cipher wrapper that returns ciphertext as a serializable cipher params object.+ */+ var SerializableCipher = C_lib.SerializableCipher = Base.extend({+ /**+ * Configuration options.+ *+ * @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL+ */+ cfg: Base.extend({+ format: OpenSSLFormatter+ }),++ /**+ * Encrypts a message.+ *+ * @param {Cipher} cipher The cipher algorithm to use.+ * @param {WordArray|string} message The message to encrypt.+ * @param {WordArray} key The key.+ * @param {Object} cfg (Optional) The configuration options to use for this operation.+ *+ * @return {CipherParams} A cipher params object.+ *+ * @static+ *+ * @example+ *+ * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key);+ * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv });+ * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL });+ */+ encrypt: function (cipher, message, key, cfg) {+ // Apply config defaults+ cfg = this.cfg.extend(cfg);++ // Encrypt+ var encryptor = cipher.createEncryptor(key, cfg);+ var ciphertext = encryptor.finalize(message);++ // Shortcut+ var cipherCfg = encryptor.cfg;++ // Create and return serializable cipher params+ return CipherParams.create({+ ciphertext: ciphertext,+ key: key,+ iv: cipherCfg.iv,+ algorithm: cipher,+ mode: cipherCfg.mode,+ padding: cipherCfg.padding,+ blockSize: cipher.blockSize,+ formatter: cfg.format+ });+ },++ /**+ * Decrypts serialized ciphertext.+ *+ * @param {Cipher} cipher The cipher algorithm to use.+ * @param {CipherParams|string} ciphertext The ciphertext to decrypt.+ * @param {WordArray} key The key.+ * @param {Object} cfg (Optional) The configuration options to use for this operation.+ *+ * @return {WordArray} The plaintext.+ *+ * @static+ *+ * @example+ *+ * var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL });+ * var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL });+ */+ decrypt: function (cipher, ciphertext, key, cfg) {+ // Apply config defaults+ cfg = this.cfg.extend(cfg);++ // Convert string to CipherParams+ ciphertext = this._parse(ciphertext, cfg.format);++ // Decrypt+ var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);++ return plaintext;+ },++ /**+ * Converts serialized ciphertext to CipherParams,+ * else assumed CipherParams already and returns ciphertext unchanged.+ *+ * @param {CipherParams|string} ciphertext The ciphertext.+ * @param {Formatter} format The formatting strategy to use to parse serialized ciphertext.+ *+ * @return {CipherParams} The unserialized ciphertext.+ *+ * @static+ *+ * @example+ *+ * var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);+ */+ _parse: function (ciphertext, format) {+ if (typeof ciphertext == 'string') {+ return format.parse(ciphertext, this);+ } else {+ return ciphertext;+ }+ }+ });++ /**+ * Key derivation function namespace.+ */+ var C_kdf = C.kdf = {};++ /**+ * OpenSSL key derivation function.+ */+ var OpenSSLKdf = C_kdf.OpenSSL = {+ /**+ * Derives a key and IV from a password.+ *+ * @param {string} password The password to derive from.+ * @param {number} keySize The size in words of the key to generate.+ * @param {number} ivSize The size in words of the IV to generate.+ * @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.+ *+ * @return {CipherParams} A cipher params object with the key, IV, and salt.+ *+ * @static+ *+ * @example+ *+ * var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32);+ * var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');+ */+ execute: function (password, keySize, ivSize, salt) {+ // Generate random salt+ if (!salt) {+ salt = WordArray.random(64/8);+ }++ // Derive key and IV+ var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt);++ // Separate key and IV+ var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);+ key.sigBytes = keySize * 4;++ // Return params+ return CipherParams.create({ key: key, iv: iv, salt: salt });+ }+ };++ /**+ * A serializable cipher wrapper that derives the key from a password,+ * and returns ciphertext as a serializable cipher params object.+ */+ var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({+ /**+ * Configuration options.+ *+ * @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL+ */+ cfg: SerializableCipher.cfg.extend({+ kdf: OpenSSLKdf+ }),++ /**+ * Encrypts a message using a password.+ *+ * @param {Cipher} cipher The cipher algorithm to use.+ * @param {WordArray|string} message The message to encrypt.+ * @param {string} password The password.+ * @param {Object} cfg (Optional) The configuration options to use for this operation.+ *+ * @return {CipherParams} A cipher params object.+ *+ * @static+ *+ * @example+ *+ * var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password');+ * var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL });+ */+ encrypt: function (cipher, message, password, cfg) {+ // Apply config defaults+ cfg = this.cfg.extend(cfg);++ // Derive key and other params+ var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize);++ // Add IV to config+ cfg.iv = derivedParams.iv;++ // Encrypt+ var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);++ // Mix in derived params+ ciphertext.mixIn(derivedParams);++ return ciphertext;+ },++ /**+ * Decrypts serialized ciphertext using a password.+ *+ * @param {Cipher} cipher The cipher algorithm to use.+ * @param {CipherParams|string} ciphertext The ciphertext to decrypt.+ * @param {string} password The password.+ * @param {Object} cfg (Optional) The configuration options to use for this operation.+ *+ * @return {WordArray} The plaintext.+ *+ * @static+ *+ * @example+ *+ * var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL });+ * var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL });+ */+ decrypt: function (cipher, ciphertext, password, cfg) {+ // Apply config defaults+ cfg = this.cfg.extend(cfg);++ // Convert string to CipherParams+ ciphertext = this._parse(ciphertext, cfg.format);++ // Derive key and other params+ var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt);++ // Add IV to config+ cfg.iv = derivedParams.iv;++ // Decrypt+ var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);++ return plaintext;+ }+ });+ }());+++}));+},{"./core":3}],3:[function(require,module,exports){+;(function (root, factory) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory();+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define([], factory);+ }+ else {+ // Global (browser)+ root.CryptoJS = factory();+ }+}(this, function () {++ /**+ * CryptoJS core components.+ */+ var CryptoJS = CryptoJS || (function (Math, undefined) {+ /*+ * Local polyfil of Object.create+ */+ var create = Object.create || (function () {+ function F() {};++ return function (obj) {+ var subtype;++ F.prototype = obj;++ subtype = new F();++ F.prototype = null;++ return subtype;+ };+ }())++ /**+ * CryptoJS namespace.+ */+ var C = {};++ /**+ * Library namespace.+ */+ var C_lib = C.lib = {};++ /**+ * Base object for prototypal inheritance.+ */+ var Base = C_lib.Base = (function () {+++ return {+ /**+ * Creates a new object that inherits from this object.+ *+ * @param {Object} overrides Properties to copy into the new object.+ *+ * @return {Object} The new object.+ *+ * @static+ *+ * @example+ *+ * var MyType = CryptoJS.lib.Base.extend({+ * field: 'value',+ *+ * method: function () {+ * }+ * });+ */+ extend: function (overrides) {+ // Spawn+ var subtype = create(this);++ // Augment+ if (overrides) {+ subtype.mixIn(overrides);+ }++ // Create default initializer+ if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {+ subtype.init = function () {+ subtype.$super.init.apply(this, arguments);+ };+ }++ // Initializer's prototype is the subtype object+ subtype.init.prototype = subtype;++ // Reference supertype+ subtype.$super = this;++ return subtype;+ },++ /**+ * Extends this object and runs the init method.+ * Arguments to create() will be passed to init().+ *+ * @return {Object} The new object.+ *+ * @static+ *+ * @example+ *+ * var instance = MyType.create();+ */+ create: function () {+ var instance = this.extend();+ instance.init.apply(instance, arguments);++ return instance;+ },++ /**+ * Initializes a newly created object.+ * Override this method to add some logic when your objects are created.+ *+ * @example+ *+ * var MyType = CryptoJS.lib.Base.extend({+ * init: function () {+ * // ...+ * }+ * });+ */+ init: function () {+ },++ /**+ * Copies properties into this object.+ *+ * @param {Object} properties The properties to mix in.+ *+ * @example+ *+ * MyType.mixIn({+ * field: 'value'+ * });+ */+ mixIn: function (properties) {+ for (var propertyName in properties) {+ if (properties.hasOwnProperty(propertyName)) {+ this[propertyName] = properties[propertyName];+ }+ }++ // IE won't copy toString using the loop above+ if (properties.hasOwnProperty('toString')) {+ this.toString = properties.toString;+ }+ },++ /**+ * Creates a copy of this object.+ *+ * @return {Object} The clone.+ *+ * @example+ *+ * var clone = instance.clone();+ */+ clone: function () {+ return this.init.prototype.extend(this);+ }+ };+ }());++ /**+ * An array of 32-bit words.+ *+ * @property {Array} words The array of 32-bit words.+ * @property {number} sigBytes The number of significant bytes in this word array.+ */+ var WordArray = C_lib.WordArray = Base.extend({+ /**+ * Initializes a newly created word array.+ *+ * @param {Array} words (Optional) An array of 32-bit words.+ * @param {number} sigBytes (Optional) The number of significant bytes in the words.+ *+ * @example+ *+ * var wordArray = CryptoJS.lib.WordArray.create();+ * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);+ * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);+ */+ init: function (words, sigBytes) {+ words = this.words = words || [];++ if (sigBytes != undefined) {+ this.sigBytes = sigBytes;+ } else {+ this.sigBytes = words.length * 4;+ }+ },++ /**+ * Converts this word array to a string.+ *+ * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex+ *+ * @return {string} The stringified word array.+ *+ * @example+ *+ * var string = wordArray + '';+ * var string = wordArray.toString();+ * var string = wordArray.toString(CryptoJS.enc.Utf8);+ */+ toString: function (encoder) {+ return (encoder || Hex).stringify(this);+ },++ /**+ * Concatenates a word array to this word array.+ *+ * @param {WordArray} wordArray The word array to append.+ *+ * @return {WordArray} This word array.+ *+ * @example+ *+ * wordArray1.concat(wordArray2);+ */+ concat: function (wordArray) {+ // Shortcuts+ var thisWords = this.words;+ var thatWords = wordArray.words;+ var thisSigBytes = this.sigBytes;+ var thatSigBytes = wordArray.sigBytes;++ // Clamp excess bits+ this.clamp();++ // Concat+ if (thisSigBytes % 4) {+ // Copy one byte at a time+ for (var i = 0; i < thatSigBytes; i++) {+ var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;+ thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);+ }+ } else {+ // Copy one word at a time+ for (var i = 0; i < thatSigBytes; i += 4) {+ thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];+ }+ }+ this.sigBytes += thatSigBytes;++ // Chainable+ return this;+ },++ /**+ * Removes insignificant bits.+ *+ * @example+ *+ * wordArray.clamp();+ */+ clamp: function () {+ // Shortcuts+ var words = this.words;+ var sigBytes = this.sigBytes;++ // Clamp+ words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);+ words.length = Math.ceil(sigBytes / 4);+ },++ /**+ * Creates a copy of this word array.+ *+ * @return {WordArray} The clone.+ *+ * @example+ *+ * var clone = wordArray.clone();+ */+ clone: function () {+ var clone = Base.clone.call(this);+ clone.words = this.words.slice(0);++ return clone;+ },++ /**+ * Creates a word array filled with random bytes.+ *+ * @param {number} nBytes The number of random bytes to generate.+ *+ * @return {WordArray} The random word array.+ *+ * @static+ *+ * @example+ *+ * var wordArray = CryptoJS.lib.WordArray.random(16);+ */+ random: function (nBytes) {+ var words = [];++ var r = (function (m_w) {+ var m_w = m_w;+ var m_z = 0x3ade68b1;+ var mask = 0xffffffff;++ return function () {+ m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;+ m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;+ var result = ((m_z << 0x10) + m_w) & mask;+ result /= 0x100000000;+ result += 0.5;+ return result * (Math.random() > .5 ? 1 : -1);+ }+ });++ for (var i = 0, rcache; i < nBytes; i += 4) {+ var _r = r((rcache || Math.random()) * 0x100000000);++ rcache = _r() * 0x3ade67b7;+ words.push((_r() * 0x100000000) | 0);+ }++ return new WordArray.init(words, nBytes);+ }+ });++ /**+ * Encoder namespace.+ */+ var C_enc = C.enc = {};++ /**+ * Hex encoding strategy.+ */+ var Hex = C_enc.Hex = {+ /**+ * Converts a word array to a hex string.+ *+ * @param {WordArray} wordArray The word array.+ *+ * @return {string} The hex string.+ *+ * @static+ *+ * @example+ *+ * var hexString = CryptoJS.enc.Hex.stringify(wordArray);+ */+ stringify: function (wordArray) {+ // Shortcuts+ var words = wordArray.words;+ var sigBytes = wordArray.sigBytes;++ // Convert+ var hexChars = [];+ for (var i = 0; i < sigBytes; i++) {+ var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;+ hexChars.push((bite >>> 4).toString(16));+ hexChars.push((bite & 0x0f).toString(16));+ }++ return hexChars.join('');+ },++ /**+ * Converts a hex string to a word array.+ *+ * @param {string} hexStr The hex string.+ *+ * @return {WordArray} The word array.+ *+ * @static+ *+ * @example+ *+ * var wordArray = CryptoJS.enc.Hex.parse(hexString);+ */+ parse: function (hexStr) {+ // Shortcut+ var hexStrLength = hexStr.length;++ // Convert+ var words = [];+ for (var i = 0; i < hexStrLength; i += 2) {+ words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);+ }++ return new WordArray.init(words, hexStrLength / 2);+ }+ };++ /**+ * Latin1 encoding strategy.+ */+ var Latin1 = C_enc.Latin1 = {+ /**+ * Converts a word array to a Latin1 string.+ *+ * @param {WordArray} wordArray The word array.+ *+ * @return {string} The Latin1 string.+ *+ * @static+ *+ * @example+ *+ * var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);+ */+ stringify: function (wordArray) {+ // Shortcuts+ var words = wordArray.words;+ var sigBytes = wordArray.sigBytes;++ // Convert+ var latin1Chars = [];+ for (var i = 0; i < sigBytes; i++) {+ var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;+ latin1Chars.push(String.fromCharCode(bite));+ }++ return latin1Chars.join('');+ },++ /**+ * Converts a Latin1 string to a word array.+ *+ * @param {string} latin1Str The Latin1 string.+ *+ * @return {WordArray} The word array.+ *+ * @static+ *+ * @example+ *+ * var wordArray = CryptoJS.enc.Latin1.parse(latin1String);+ */+ parse: function (latin1Str) {+ // Shortcut+ var latin1StrLength = latin1Str.length;++ // Convert+ var words = [];+ for (var i = 0; i < latin1StrLength; i++) {+ words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);+ }++ return new WordArray.init(words, latin1StrLength);+ }+ };++ /**+ * UTF-8 encoding strategy.+ */+ var Utf8 = C_enc.Utf8 = {+ /**+ * Converts a word array to a UTF-8 string.+ *+ * @param {WordArray} wordArray The word array.+ *+ * @return {string} The UTF-8 string.+ *+ * @static+ *+ * @example+ *+ * var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);+ */+ stringify: function (wordArray) {+ try {+ return decodeURIComponent(escape(Latin1.stringify(wordArray)));+ } catch (e) {+ throw new Error('Malformed UTF-8 data');+ }+ },++ /**+ * Converts a UTF-8 string to a word array.+ *+ * @param {string} utf8Str The UTF-8 string.+ *+ * @return {WordArray} The word array.+ *+ * @static+ *+ * @example+ *+ * var wordArray = CryptoJS.enc.Utf8.parse(utf8String);+ */+ parse: function (utf8Str) {+ return Latin1.parse(unescape(encodeURIComponent(utf8Str)));+ }+ };++ /**+ * Abstract buffered block algorithm template.+ *+ * The property blockSize must be implemented in a concrete subtype.+ *+ * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0+ */+ var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({+ /**+ * Resets this block algorithm's data buffer to its initial state.+ *+ * @example+ *+ * bufferedBlockAlgorithm.reset();+ */+ reset: function () {+ // Initial values+ this._data = new WordArray.init();+ this._nDataBytes = 0;+ },++ /**+ * Adds new data to this block algorithm's buffer.+ *+ * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.+ *+ * @example+ *+ * bufferedBlockAlgorithm._append('data');+ * bufferedBlockAlgorithm._append(wordArray);+ */+ _append: function (data) {+ // Convert string to WordArray, else assume WordArray already+ if (typeof data == 'string') {+ data = Utf8.parse(data);+ }++ // Append+ this._data.concat(data);+ this._nDataBytes += data.sigBytes;+ },++ /**+ * Processes available data blocks.+ *+ * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.+ *+ * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.+ *+ * @return {WordArray} The processed data.+ *+ * @example+ *+ * var processedData = bufferedBlockAlgorithm._process();+ * var processedData = bufferedBlockAlgorithm._process(!!'flush');+ */+ _process: function (doFlush) {+ // Shortcuts+ var data = this._data;+ var dataWords = data.words;+ var dataSigBytes = data.sigBytes;+ var blockSize = this.blockSize;+ var blockSizeBytes = blockSize * 4;++ // Count blocks ready+ var nBlocksReady = dataSigBytes / blockSizeBytes;+ if (doFlush) {+ // Round up to include partial blocks+ nBlocksReady = Math.ceil(nBlocksReady);+ } else {+ // Round down to include only full blocks,+ // less the number of blocks that must remain in the buffer+ nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);+ }++ // Count words ready+ var nWordsReady = nBlocksReady * blockSize;++ // Count bytes ready+ var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);++ // Process blocks+ if (nWordsReady) {+ for (var offset = 0; offset < nWordsReady; offset += blockSize) {+ // Perform concrete-algorithm logic+ this._doProcessBlock(dataWords, offset);+ }++ // Remove processed words+ var processedWords = dataWords.splice(0, nWordsReady);+ data.sigBytes -= nBytesReady;+ }++ // Return processed words+ return new WordArray.init(processedWords, nBytesReady);+ },++ /**+ * Creates a copy of this object.+ *+ * @return {Object} The clone.+ *+ * @example+ *+ * var clone = bufferedBlockAlgorithm.clone();+ */+ clone: function () {+ var clone = Base.clone.call(this);+ clone._data = this._data.clone();++ return clone;+ },++ _minBufferSize: 0+ });++ /**+ * Abstract hasher template.+ *+ * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)+ */+ var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({+ /**+ * Configuration options.+ */+ cfg: Base.extend(),++ /**+ * Initializes a newly created hasher.+ *+ * @param {Object} cfg (Optional) The configuration options to use for this hash computation.+ *+ * @example+ *+ * var hasher = CryptoJS.algo.SHA256.create();+ */+ init: function (cfg) {+ // Apply config defaults+ this.cfg = this.cfg.extend(cfg);++ // Set initial values+ this.reset();+ },++ /**+ * Resets this hasher to its initial state.+ *+ * @example+ *+ * hasher.reset();+ */+ reset: function () {+ // Reset data buffer+ BufferedBlockAlgorithm.reset.call(this);++ // Perform concrete-hasher logic+ this._doReset();+ },++ /**+ * Updates this hasher with a message.+ *+ * @param {WordArray|string} messageUpdate The message to append.+ *+ * @return {Hasher} This hasher.+ *+ * @example+ *+ * hasher.update('message');+ * hasher.update(wordArray);+ */+ update: function (messageUpdate) {+ // Append+ this._append(messageUpdate);++ // Update the hash+ this._process();++ // Chainable+ return this;+ },++ /**+ * Finalizes the hash computation.+ * Note that the finalize operation is effectively a destructive, read-once operation.+ *+ * @param {WordArray|string} messageUpdate (Optional) A final message update.+ *+ * @return {WordArray} The hash.+ *+ * @example+ *+ * var hash = hasher.finalize();+ * var hash = hasher.finalize('message');+ * var hash = hasher.finalize(wordArray);+ */+ finalize: function (messageUpdate) {+ // Final message update+ if (messageUpdate) {+ this._append(messageUpdate);+ }++ // Perform concrete-hasher logic+ var hash = this._doFinalize();++ return hash;+ },++ blockSize: 512/32,++ /**+ * Creates a shortcut function to a hasher's object interface.+ *+ * @param {Hasher} hasher The hasher to create a helper for.+ *+ * @return {Function} The shortcut function.+ *+ * @static+ *+ * @example+ *+ * var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);+ */+ _createHelper: function (hasher) {+ return function (message, cfg) {+ return new hasher.init(cfg).finalize(message);+ };+ },++ /**+ * Creates a shortcut function to the HMAC's object interface.+ *+ * @param {Hasher} hasher The hasher to use in this HMAC helper.+ *+ * @return {Function} The shortcut function.+ *+ * @static+ *+ * @example+ *+ * var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);+ */+ _createHmacHelper: function (hasher) {+ return function (message, key) {+ return new C_algo.HMAC.init(hasher, key).finalize(message);+ };+ }+ });++ /**+ * Algorithm namespace.+ */+ var C_algo = C.algo = {};++ return C;+ }(Math));+++ return CryptoJS;++}));+},{}],4:[function(require,module,exports){+;(function (root, factory) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function () {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var WordArray = C_lib.WordArray;+ var C_enc = C.enc;++ /**+ * Base64 encoding strategy.+ */+ var Base64 = C_enc.Base64 = {+ /**+ * Converts a word array to a Base64 string.+ *+ * @param {WordArray} wordArray The word array.+ *+ * @return {string} The Base64 string.+ *+ * @static+ *+ * @example+ *+ * var base64String = CryptoJS.enc.Base64.stringify(wordArray);+ */+ stringify: function (wordArray) {+ // Shortcuts+ var words = wordArray.words;+ var sigBytes = wordArray.sigBytes;+ var map = this._map;++ // Clamp excess bits+ wordArray.clamp();++ // Convert+ var base64Chars = [];+ for (var i = 0; i < sigBytes; i += 3) {+ var byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;+ var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;+ var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;++ var triplet = (byte1 << 16) | (byte2 << 8) | byte3;++ for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) {+ base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));+ }+ }++ // Add padding+ var paddingChar = map.charAt(64);+ if (paddingChar) {+ while (base64Chars.length % 4) {+ base64Chars.push(paddingChar);+ }+ }++ return base64Chars.join('');+ },++ /**+ * Converts a Base64 string to a word array.+ *+ * @param {string} base64Str The Base64 string.+ *+ * @return {WordArray} The word array.+ *+ * @static+ *+ * @example+ *+ * var wordArray = CryptoJS.enc.Base64.parse(base64String);+ */+ parse: function (base64Str) {+ // Shortcuts+ var base64StrLength = base64Str.length;+ var map = this._map;+ var reverseMap = this._reverseMap;++ if (!reverseMap) {+ reverseMap = this._reverseMap = [];+ for (var j = 0; j < map.length; j++) {+ reverseMap[map.charCodeAt(j)] = j;+ }+ }++ // Ignore padding+ var paddingChar = map.charAt(64);+ if (paddingChar) {+ var paddingIndex = base64Str.indexOf(paddingChar);+ if (paddingIndex !== -1) {+ base64StrLength = paddingIndex;+ }+ }++ // Convert+ return parseLoop(base64Str, base64StrLength, reverseMap);++ },++ _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='+ };++ function parseLoop(base64Str, base64StrLength, reverseMap) {+ var words = [];+ var nBytes = 0;+ for (var i = 0; i < base64StrLength; i++) {+ if (i % 4) {+ var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2);+ var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2);+ words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8);+ nBytes++;+ }+ }+ return WordArray.create(words, nBytes);+ }+ }());+++ return CryptoJS.enc.Base64;++}));+},{"./core":3}],5:[function(require,module,exports){+;(function (root, factory) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function () {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var WordArray = C_lib.WordArray;+ var C_enc = C.enc;++ /**+ * UTF-16 BE encoding strategy.+ */+ var Utf16BE = C_enc.Utf16 = C_enc.Utf16BE = {+ /**+ * Converts a word array to a UTF-16 BE string.+ *+ * @param {WordArray} wordArray The word array.+ *+ * @return {string} The UTF-16 BE string.+ *+ * @static+ *+ * @example+ *+ * var utf16String = CryptoJS.enc.Utf16.stringify(wordArray);+ */+ stringify: function (wordArray) {+ // Shortcuts+ var words = wordArray.words;+ var sigBytes = wordArray.sigBytes;++ // Convert+ var utf16Chars = [];+ for (var i = 0; i < sigBytes; i += 2) {+ var codePoint = (words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff;+ utf16Chars.push(String.fromCharCode(codePoint));+ }++ return utf16Chars.join('');+ },++ /**+ * Converts a UTF-16 BE string to a word array.+ *+ * @param {string} utf16Str The UTF-16 BE string.+ *+ * @return {WordArray} The word array.+ *+ * @static+ *+ * @example+ *+ * var wordArray = CryptoJS.enc.Utf16.parse(utf16String);+ */+ parse: function (utf16Str) {+ // Shortcut+ var utf16StrLength = utf16Str.length;++ // Convert+ var words = [];+ for (var i = 0; i < utf16StrLength; i++) {+ words[i >>> 1] |= utf16Str.charCodeAt(i) << (16 - (i % 2) * 16);+ }++ return WordArray.create(words, utf16StrLength * 2);+ }+ };++ /**+ * UTF-16 LE encoding strategy.+ */+ C_enc.Utf16LE = {+ /**+ * Converts a word array to a UTF-16 LE string.+ *+ * @param {WordArray} wordArray The word array.+ *+ * @return {string} The UTF-16 LE string.+ *+ * @static+ *+ * @example+ *+ * var utf16Str = CryptoJS.enc.Utf16LE.stringify(wordArray);+ */+ stringify: function (wordArray) {+ // Shortcuts+ var words = wordArray.words;+ var sigBytes = wordArray.sigBytes;++ // Convert+ var utf16Chars = [];+ for (var i = 0; i < sigBytes; i += 2) {+ var codePoint = swapEndian((words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff);+ utf16Chars.push(String.fromCharCode(codePoint));+ }++ return utf16Chars.join('');+ },++ /**+ * Converts a UTF-16 LE string to a word array.+ *+ * @param {string} utf16Str The UTF-16 LE string.+ *+ * @return {WordArray} The word array.+ *+ * @static+ *+ * @example+ *+ * var wordArray = CryptoJS.enc.Utf16LE.parse(utf16Str);+ */+ parse: function (utf16Str) {+ // Shortcut+ var utf16StrLength = utf16Str.length;++ // Convert+ var words = [];+ for (var i = 0; i < utf16StrLength; i++) {+ words[i >>> 1] |= swapEndian(utf16Str.charCodeAt(i) << (16 - (i % 2) * 16));+ }++ return WordArray.create(words, utf16StrLength * 2);+ }+ };++ function swapEndian(word) {+ return ((word << 8) & 0xff00ff00) | ((word >>> 8) & 0x00ff00ff);+ }+ }());+++ return CryptoJS.enc.Utf16;++}));+},{"./core":3}],6:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./sha1"), require("./hmac"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./sha1", "./hmac"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function () {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var Base = C_lib.Base;+ var WordArray = C_lib.WordArray;+ var C_algo = C.algo;+ var MD5 = C_algo.MD5;++ /**+ * This key derivation function is meant to conform with EVP_BytesToKey.+ * www.openssl.org/docs/crypto/EVP_BytesToKey.html+ */+ var EvpKDF = C_algo.EvpKDF = Base.extend({+ /**+ * Configuration options.+ *+ * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)+ * @property {Hasher} hasher The hash algorithm to use. Default: MD5+ * @property {number} iterations The number of iterations to perform. Default: 1+ */+ cfg: Base.extend({+ keySize: 128/32,+ hasher: MD5,+ iterations: 1+ }),++ /**+ * Initializes a newly created key derivation function.+ *+ * @param {Object} cfg (Optional) The configuration options to use for the derivation.+ *+ * @example+ *+ * var kdf = CryptoJS.algo.EvpKDF.create();+ * var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });+ * var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });+ */+ init: function (cfg) {+ this.cfg = this.cfg.extend(cfg);+ },++ /**+ * Derives a key from a password.+ *+ * @param {WordArray|string} password The password.+ * @param {WordArray|string} salt A salt.+ *+ * @return {WordArray} The derived key.+ *+ * @example+ *+ * var key = kdf.compute(password, salt);+ */+ compute: function (password, salt) {+ // Shortcut+ var cfg = this.cfg;++ // Init hasher+ var hasher = cfg.hasher.create();++ // Initial values+ var derivedKey = WordArray.create();++ // Shortcuts+ var derivedKeyWords = derivedKey.words;+ var keySize = cfg.keySize;+ var iterations = cfg.iterations;++ // Generate key+ while (derivedKeyWords.length < keySize) {+ if (block) {+ hasher.update(block);+ }+ var block = hasher.update(password).finalize(salt);+ hasher.reset();++ // Iterations+ for (var i = 1; i < iterations; i++) {+ block = hasher.finalize(block);+ hasher.reset();+ }++ derivedKey.concat(block);+ }+ derivedKey.sigBytes = keySize * 4;++ return derivedKey;+ }+ });++ /**+ * Derives a key from a password.+ *+ * @param {WordArray|string} password The password.+ * @param {WordArray|string} salt A salt.+ * @param {Object} cfg (Optional) The configuration options to use for this computation.+ *+ * @return {WordArray} The derived key.+ *+ * @static+ *+ * @example+ *+ * var key = CryptoJS.EvpKDF(password, salt);+ * var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });+ * var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });+ */+ C.EvpKDF = function (password, salt, cfg) {+ return EvpKDF.create(cfg).compute(password, salt);+ };+ }());+++ return CryptoJS.EvpKDF;++}));+},{"./core":3,"./hmac":8,"./sha1":27}],7:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./cipher-core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./cipher-core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function (undefined) {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var CipherParams = C_lib.CipherParams;+ var C_enc = C.enc;+ var Hex = C_enc.Hex;+ var C_format = C.format;++ var HexFormatter = C_format.Hex = {+ /**+ * Converts the ciphertext of a cipher params object to a hexadecimally encoded string.+ *+ * @param {CipherParams} cipherParams The cipher params object.+ *+ * @return {string} The hexadecimally encoded string.+ *+ * @static+ *+ * @example+ *+ * var hexString = CryptoJS.format.Hex.stringify(cipherParams);+ */+ stringify: function (cipherParams) {+ return cipherParams.ciphertext.toString(Hex);+ },++ /**+ * Converts a hexadecimally encoded ciphertext string to a cipher params object.+ *+ * @param {string} input The hexadecimally encoded string.+ *+ * @return {CipherParams} The cipher params object.+ *+ * @static+ *+ * @example+ *+ * var cipherParams = CryptoJS.format.Hex.parse(hexString);+ */+ parse: function (input) {+ var ciphertext = Hex.parse(input);+ return CipherParams.create({ ciphertext: ciphertext });+ }+ };+ }());+++ return CryptoJS.format.Hex;++}));+},{"./cipher-core":2,"./core":3}],8:[function(require,module,exports){+;(function (root, factory) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function () {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var Base = C_lib.Base;+ var C_enc = C.enc;+ var Utf8 = C_enc.Utf8;+ var C_algo = C.algo;++ /**+ * HMAC algorithm.+ */+ var HMAC = C_algo.HMAC = Base.extend({+ /**+ * Initializes a newly created HMAC.+ *+ * @param {Hasher} hasher The hash algorithm to use.+ * @param {WordArray|string} key The secret key.+ *+ * @example+ *+ * var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);+ */+ init: function (hasher, key) {+ // Init hasher+ hasher = this._hasher = new hasher.init();++ // Convert string to WordArray, else assume WordArray already+ if (typeof key == 'string') {+ key = Utf8.parse(key);+ }++ // Shortcuts+ var hasherBlockSize = hasher.blockSize;+ var hasherBlockSizeBytes = hasherBlockSize * 4;++ // Allow arbitrary length keys+ if (key.sigBytes > hasherBlockSizeBytes) {+ key = hasher.finalize(key);+ }++ // Clamp excess bits+ key.clamp();++ // Clone key for inner and outer pads+ var oKey = this._oKey = key.clone();+ var iKey = this._iKey = key.clone();++ // Shortcuts+ var oKeyWords = oKey.words;+ var iKeyWords = iKey.words;++ // XOR keys with pad constants+ for (var i = 0; i < hasherBlockSize; i++) {+ oKeyWords[i] ^= 0x5c5c5c5c;+ iKeyWords[i] ^= 0x36363636;+ }+ oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;++ // Set initial values+ this.reset();+ },++ /**+ * Resets this HMAC to its initial state.+ *+ * @example+ *+ * hmacHasher.reset();+ */+ reset: function () {+ // Shortcut+ var hasher = this._hasher;++ // Reset+ hasher.reset();+ hasher.update(this._iKey);+ },++ /**+ * Updates this HMAC with a message.+ *+ * @param {WordArray|string} messageUpdate The message to append.+ *+ * @return {HMAC} This HMAC instance.+ *+ * @example+ *+ * hmacHasher.update('message');+ * hmacHasher.update(wordArray);+ */+ update: function (messageUpdate) {+ this._hasher.update(messageUpdate);++ // Chainable+ return this;+ },++ /**+ * Finalizes the HMAC computation.+ * Note that the finalize operation is effectively a destructive, read-once operation.+ *+ * @param {WordArray|string} messageUpdate (Optional) A final message update.+ *+ * @return {WordArray} The HMAC.+ *+ * @example+ *+ * var hmac = hmacHasher.finalize();+ * var hmac = hmacHasher.finalize('message');+ * var hmac = hmacHasher.finalize(wordArray);+ */+ finalize: function (messageUpdate) {+ // Shortcut+ var hasher = this._hasher;++ // Compute HMAC+ var innerHash = hasher.finalize(messageUpdate);+ hasher.reset();+ var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));++ return hmac;+ }+ });+ }());+++}));+},{"./core":3}],9:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./x64-core"), require("./lib-typedarrays"), require("./enc-utf16"), require("./enc-base64"), require("./md5"), require("./sha1"), require("./sha256"), require("./sha224"), require("./sha512"), require("./sha384"), require("./sha3"), require("./ripemd160"), require("./hmac"), require("./pbkdf2"), require("./evpkdf"), require("./cipher-core"), require("./mode-cfb"), require("./mode-ctr"), require("./mode-ctr-gladman"), require("./mode-ofb"), require("./mode-ecb"), require("./pad-ansix923"), require("./pad-iso10126"), require("./pad-iso97971"), require("./pad-zeropadding"), require("./pad-nopadding"), require("./format-hex"), require("./aes"), require("./tripledes"), require("./rc4"), require("./rabbit"), require("./rabbit-legacy"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./x64-core", "./lib-typedarrays", "./enc-utf16", "./enc-base64", "./md5", "./sha1", "./sha256", "./sha224", "./sha512", "./sha384", "./sha3", "./ripemd160", "./hmac", "./pbkdf2", "./evpkdf", "./cipher-core", "./mode-cfb", "./mode-ctr", "./mode-ctr-gladman", "./mode-ofb", "./mode-ecb", "./pad-ansix923", "./pad-iso10126", "./pad-iso97971", "./pad-zeropadding", "./pad-nopadding", "./format-hex", "./aes", "./tripledes", "./rc4", "./rabbit", "./rabbit-legacy"], factory);+ }+ else {+ // Global (browser)+ root.CryptoJS = factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ return CryptoJS;++}));+},{"./aes":1,"./cipher-core":2,"./core":3,"./enc-base64":4,"./enc-utf16":5,"./evpkdf":6,"./format-hex":7,"./hmac":8,"./lib-typedarrays":10,"./md5":11,"./mode-cfb":12,"./mode-ctr":14,"./mode-ctr-gladman":13,"./mode-ecb":15,"./mode-ofb":16,"./pad-ansix923":17,"./pad-iso10126":18,"./pad-iso97971":19,"./pad-nopadding":20,"./pad-zeropadding":21,"./pbkdf2":22,"./rabbit":24,"./rabbit-legacy":23,"./rc4":25,"./ripemd160":26,"./sha1":27,"./sha224":28,"./sha256":29,"./sha3":30,"./sha384":31,"./sha512":32,"./tripledes":33,"./x64-core":34}],10:[function(require,module,exports){+;(function (root, factory) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function () {+ // Check if typed arrays are supported+ if (typeof ArrayBuffer != 'function') {+ return;+ }++ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var WordArray = C_lib.WordArray;++ // Reference original init+ var superInit = WordArray.init;++ // Augment WordArray.init to handle typed arrays+ var subInit = WordArray.init = function (typedArray) {+ // Convert buffers to uint8+ if (typedArray instanceof ArrayBuffer) {+ typedArray = new Uint8Array(typedArray);+ }++ // Convert other array views to uint8+ if (+ typedArray instanceof Int8Array ||+ (typeof Uint8ClampedArray !== "undefined" && typedArray instanceof Uint8ClampedArray) ||+ typedArray instanceof Int16Array ||+ typedArray instanceof Uint16Array ||+ typedArray instanceof Int32Array ||+ typedArray instanceof Uint32Array ||+ typedArray instanceof Float32Array ||+ typedArray instanceof Float64Array+ ) {+ typedArray = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);+ }++ // Handle Uint8Array+ if (typedArray instanceof Uint8Array) {+ // Shortcut+ var typedArrayByteLength = typedArray.byteLength;++ // Extract bytes+ var words = [];+ for (var i = 0; i < typedArrayByteLength; i++) {+ words[i >>> 2] |= typedArray[i] << (24 - (i % 4) * 8);+ }++ // Initialize this word array+ superInit.call(this, words, typedArrayByteLength);+ } else {+ // Else call normal init+ superInit.apply(this, arguments);+ }+ };++ subInit.prototype = WordArray;+ }());+++ return CryptoJS.lib.WordArray;++}));+},{"./core":3}],11:[function(require,module,exports){+;(function (root, factory) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function (Math) {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var WordArray = C_lib.WordArray;+ var Hasher = C_lib.Hasher;+ var C_algo = C.algo;++ // Constants table+ var T = [];++ // Compute constants+ (function () {+ for (var i = 0; i < 64; i++) {+ T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0;+ }+ }());++ /**+ * MD5 hash algorithm.+ */+ var MD5 = C_algo.MD5 = Hasher.extend({+ _doReset: function () {+ this._hash = new WordArray.init([+ 0x67452301, 0xefcdab89,+ 0x98badcfe, 0x10325476+ ]);+ },++ _doProcessBlock: function (M, offset) {+ // Swap endian+ for (var i = 0; i < 16; i++) {+ // Shortcuts+ var offset_i = offset + i;+ var M_offset_i = M[offset_i];++ M[offset_i] = (+ (((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) |+ (((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00)+ );+ }++ // Shortcuts+ var H = this._hash.words;++ var M_offset_0 = M[offset + 0];+ var M_offset_1 = M[offset + 1];+ var M_offset_2 = M[offset + 2];+ var M_offset_3 = M[offset + 3];+ var M_offset_4 = M[offset + 4];+ var M_offset_5 = M[offset + 5];+ var M_offset_6 = M[offset + 6];+ var M_offset_7 = M[offset + 7];+ var M_offset_8 = M[offset + 8];+ var M_offset_9 = M[offset + 9];+ var M_offset_10 = M[offset + 10];+ var M_offset_11 = M[offset + 11];+ var M_offset_12 = M[offset + 12];+ var M_offset_13 = M[offset + 13];+ var M_offset_14 = M[offset + 14];+ var M_offset_15 = M[offset + 15];++ // Working varialbes+ var a = H[0];+ var b = H[1];+ var c = H[2];+ var d = H[3];++ // Computation+ a = FF(a, b, c, d, M_offset_0, 7, T[0]);+ d = FF(d, a, b, c, M_offset_1, 12, T[1]);+ c = FF(c, d, a, b, M_offset_2, 17, T[2]);+ b = FF(b, c, d, a, M_offset_3, 22, T[3]);+ a = FF(a, b, c, d, M_offset_4, 7, T[4]);+ d = FF(d, a, b, c, M_offset_5, 12, T[5]);+ c = FF(c, d, a, b, M_offset_6, 17, T[6]);+ b = FF(b, c, d, a, M_offset_7, 22, T[7]);+ a = FF(a, b, c, d, M_offset_8, 7, T[8]);+ d = FF(d, a, b, c, M_offset_9, 12, T[9]);+ c = FF(c, d, a, b, M_offset_10, 17, T[10]);+ b = FF(b, c, d, a, M_offset_11, 22, T[11]);+ a = FF(a, b, c, d, M_offset_12, 7, T[12]);+ d = FF(d, a, b, c, M_offset_13, 12, T[13]);+ c = FF(c, d, a, b, M_offset_14, 17, T[14]);+ b = FF(b, c, d, a, M_offset_15, 22, T[15]);++ a = GG(a, b, c, d, M_offset_1, 5, T[16]);+ d = GG(d, a, b, c, M_offset_6, 9, T[17]);+ c = GG(c, d, a, b, M_offset_11, 14, T[18]);+ b = GG(b, c, d, a, M_offset_0, 20, T[19]);+ a = GG(a, b, c, d, M_offset_5, 5, T[20]);+ d = GG(d, a, b, c, M_offset_10, 9, T[21]);+ c = GG(c, d, a, b, M_offset_15, 14, T[22]);+ b = GG(b, c, d, a, M_offset_4, 20, T[23]);+ a = GG(a, b, c, d, M_offset_9, 5, T[24]);+ d = GG(d, a, b, c, M_offset_14, 9, T[25]);+ c = GG(c, d, a, b, M_offset_3, 14, T[26]);+ b = GG(b, c, d, a, M_offset_8, 20, T[27]);+ a = GG(a, b, c, d, M_offset_13, 5, T[28]);+ d = GG(d, a, b, c, M_offset_2, 9, T[29]);+ c = GG(c, d, a, b, M_offset_7, 14, T[30]);+ b = GG(b, c, d, a, M_offset_12, 20, T[31]);++ a = HH(a, b, c, d, M_offset_5, 4, T[32]);+ d = HH(d, a, b, c, M_offset_8, 11, T[33]);+ c = HH(c, d, a, b, M_offset_11, 16, T[34]);+ b = HH(b, c, d, a, M_offset_14, 23, T[35]);+ a = HH(a, b, c, d, M_offset_1, 4, T[36]);+ d = HH(d, a, b, c, M_offset_4, 11, T[37]);+ c = HH(c, d, a, b, M_offset_7, 16, T[38]);+ b = HH(b, c, d, a, M_offset_10, 23, T[39]);+ a = HH(a, b, c, d, M_offset_13, 4, T[40]);+ d = HH(d, a, b, c, M_offset_0, 11, T[41]);+ c = HH(c, d, a, b, M_offset_3, 16, T[42]);+ b = HH(b, c, d, a, M_offset_6, 23, T[43]);+ a = HH(a, b, c, d, M_offset_9, 4, T[44]);+ d = HH(d, a, b, c, M_offset_12, 11, T[45]);+ c = HH(c, d, a, b, M_offset_15, 16, T[46]);+ b = HH(b, c, d, a, M_offset_2, 23, T[47]);++ a = II(a, b, c, d, M_offset_0, 6, T[48]);+ d = II(d, a, b, c, M_offset_7, 10, T[49]);+ c = II(c, d, a, b, M_offset_14, 15, T[50]);+ b = II(b, c, d, a, M_offset_5, 21, T[51]);+ a = II(a, b, c, d, M_offset_12, 6, T[52]);+ d = II(d, a, b, c, M_offset_3, 10, T[53]);+ c = II(c, d, a, b, M_offset_10, 15, T[54]);+ b = II(b, c, d, a, M_offset_1, 21, T[55]);+ a = II(a, b, c, d, M_offset_8, 6, T[56]);+ d = II(d, a, b, c, M_offset_15, 10, T[57]);+ c = II(c, d, a, b, M_offset_6, 15, T[58]);+ b = II(b, c, d, a, M_offset_13, 21, T[59]);+ a = II(a, b, c, d, M_offset_4, 6, T[60]);+ d = II(d, a, b, c, M_offset_11, 10, T[61]);+ c = II(c, d, a, b, M_offset_2, 15, T[62]);+ b = II(b, c, d, a, M_offset_9, 21, T[63]);++ // Intermediate hash value+ H[0] = (H[0] + a) | 0;+ H[1] = (H[1] + b) | 0;+ H[2] = (H[2] + c) | 0;+ H[3] = (H[3] + d) | 0;+ },++ _doFinalize: function () {+ // Shortcuts+ var data = this._data;+ var dataWords = data.words;++ var nBitsTotal = this._nDataBytes * 8;+ var nBitsLeft = data.sigBytes * 8;++ // Add padding+ dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);++ var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);+ var nBitsTotalL = nBitsTotal;+ dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (+ (((nBitsTotalH << 8) | (nBitsTotalH >>> 24)) & 0x00ff00ff) |+ (((nBitsTotalH << 24) | (nBitsTotalH >>> 8)) & 0xff00ff00)+ );+ dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (+ (((nBitsTotalL << 8) | (nBitsTotalL >>> 24)) & 0x00ff00ff) |+ (((nBitsTotalL << 24) | (nBitsTotalL >>> 8)) & 0xff00ff00)+ );++ data.sigBytes = (dataWords.length + 1) * 4;++ // Hash final blocks+ this._process();++ // Shortcuts+ var hash = this._hash;+ var H = hash.words;++ // Swap endian+ for (var i = 0; i < 4; i++) {+ // Shortcut+ var H_i = H[i];++ H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) |+ (((H_i << 24) | (H_i >>> 8)) & 0xff00ff00);+ }++ // Return final computed hash+ return hash;+ },++ clone: function () {+ var clone = Hasher.clone.call(this);+ clone._hash = this._hash.clone();++ return clone;+ }+ });++ function FF(a, b, c, d, x, s, t) {+ var n = a + ((b & c) | (~b & d)) + x + t;+ return ((n << s) | (n >>> (32 - s))) + b;+ }++ function GG(a, b, c, d, x, s, t) {+ var n = a + ((b & d) | (c & ~d)) + x + t;+ return ((n << s) | (n >>> (32 - s))) + b;+ }++ function HH(a, b, c, d, x, s, t) {+ var n = a + (b ^ c ^ d) + x + t;+ return ((n << s) | (n >>> (32 - s))) + b;+ }++ function II(a, b, c, d, x, s, t) {+ var n = a + (c ^ (b | ~d)) + x + t;+ return ((n << s) | (n >>> (32 - s))) + b;+ }++ /**+ * Shortcut function to the hasher's object interface.+ *+ * @param {WordArray|string} message The message to hash.+ *+ * @return {WordArray} The hash.+ *+ * @static+ *+ * @example+ *+ * var hash = CryptoJS.MD5('message');+ * var hash = CryptoJS.MD5(wordArray);+ */+ C.MD5 = Hasher._createHelper(MD5);++ /**+ * Shortcut function to the HMAC's object interface.+ *+ * @param {WordArray|string} message The message to hash.+ * @param {WordArray|string} key The secret key.+ *+ * @return {WordArray} The HMAC.+ *+ * @static+ *+ * @example+ *+ * var hmac = CryptoJS.HmacMD5(message, key);+ */+ C.HmacMD5 = Hasher._createHmacHelper(MD5);+ }(Math));+++ return CryptoJS.MD5;++}));+},{"./core":3}],12:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./cipher-core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./cipher-core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ /**+ * Cipher Feedback block mode.+ */+ CryptoJS.mode.CFB = (function () {+ var CFB = CryptoJS.lib.BlockCipherMode.extend();++ CFB.Encryptor = CFB.extend({+ processBlock: function (words, offset) {+ // Shortcuts+ var cipher = this._cipher;+ var blockSize = cipher.blockSize;++ generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher);++ // Remember this block to use with next block+ this._prevBlock = words.slice(offset, offset + blockSize);+ }+ });++ CFB.Decryptor = CFB.extend({+ processBlock: function (words, offset) {+ // Shortcuts+ var cipher = this._cipher;+ var blockSize = cipher.blockSize;++ // Remember this block to use with next block+ var thisBlock = words.slice(offset, offset + blockSize);++ generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher);++ // This block becomes the previous block+ this._prevBlock = thisBlock;+ }+ });++ function generateKeystreamAndEncrypt(words, offset, blockSize, cipher) {+ // Shortcut+ var iv = this._iv;++ // Generate keystream+ if (iv) {+ var keystream = iv.slice(0);++ // Remove IV for subsequent blocks+ this._iv = undefined;+ } else {+ var keystream = this._prevBlock;+ }+ cipher.encryptBlock(keystream, 0);++ // Encrypt+ for (var i = 0; i < blockSize; i++) {+ words[offset + i] ^= keystream[i];+ }+ }++ return CFB;+ }());+++ return CryptoJS.mode.CFB;++}));+},{"./cipher-core":2,"./core":3}],13:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./cipher-core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./cipher-core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ /** @preserve+ * Counter block mode compatible with Dr Brian Gladman fileenc.c+ * derived from CryptoJS.mode.CTR+ * Jan Hruby jhruby.web@gmail.com+ */+ CryptoJS.mode.CTRGladman = (function () {+ var CTRGladman = CryptoJS.lib.BlockCipherMode.extend();++ function incWord(word)+ {+ if (((word >> 24) & 0xff) === 0xff) { //overflow+ var b1 = (word >> 16)&0xff;+ var b2 = (word >> 8)&0xff;+ var b3 = word & 0xff;++ if (b1 === 0xff) // overflow b1+ {+ b1 = 0;+ if (b2 === 0xff)+ {+ b2 = 0;+ if (b3 === 0xff)+ {+ b3 = 0;+ }+ else+ {+ ++b3;+ }+ }+ else+ {+ ++b2;+ }+ }+ else+ {+ ++b1;+ }++ word = 0;+ word += (b1 << 16);+ word += (b2 << 8);+ word += b3;+ }+ else+ {+ word += (0x01 << 24);+ }+ return word;+ }++ function incCounter(counter)+ {+ if ((counter[0] = incWord(counter[0])) === 0)+ {+ // encr_data in fileenc.c from Dr Brian Gladman's counts only with DWORD j < 8+ counter[1] = incWord(counter[1]);+ }+ return counter;+ }++ var Encryptor = CTRGladman.Encryptor = CTRGladman.extend({+ processBlock: function (words, offset) {+ // Shortcuts+ var cipher = this._cipher+ var blockSize = cipher.blockSize;+ var iv = this._iv;+ var counter = this._counter;++ // Generate keystream+ if (iv) {+ counter = this._counter = iv.slice(0);++ // Remove IV for subsequent blocks+ this._iv = undefined;+ }++ incCounter(counter);++ var keystream = counter.slice(0);+ cipher.encryptBlock(keystream, 0);++ // Encrypt+ for (var i = 0; i < blockSize; i++) {+ words[offset + i] ^= keystream[i];+ }+ }+ });++ CTRGladman.Decryptor = Encryptor;++ return CTRGladman;+ }());+++++ return CryptoJS.mode.CTRGladman;++}));+},{"./cipher-core":2,"./core":3}],14:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./cipher-core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./cipher-core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ /**+ * Counter block mode.+ */+ CryptoJS.mode.CTR = (function () {+ var CTR = CryptoJS.lib.BlockCipherMode.extend();++ var Encryptor = CTR.Encryptor = CTR.extend({+ processBlock: function (words, offset) {+ // Shortcuts+ var cipher = this._cipher+ var blockSize = cipher.blockSize;+ var iv = this._iv;+ var counter = this._counter;++ // Generate keystream+ if (iv) {+ counter = this._counter = iv.slice(0);++ // Remove IV for subsequent blocks+ this._iv = undefined;+ }+ var keystream = counter.slice(0);+ cipher.encryptBlock(keystream, 0);++ // Increment counter+ counter[blockSize - 1] = (counter[blockSize - 1] + 1) | 0++ // Encrypt+ for (var i = 0; i < blockSize; i++) {+ words[offset + i] ^= keystream[i];+ }+ }+ });++ CTR.Decryptor = Encryptor;++ return CTR;+ }());+++ return CryptoJS.mode.CTR;++}));+},{"./cipher-core":2,"./core":3}],15:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./cipher-core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./cipher-core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ /**+ * Electronic Codebook block mode.+ */+ CryptoJS.mode.ECB = (function () {+ var ECB = CryptoJS.lib.BlockCipherMode.extend();++ ECB.Encryptor = ECB.extend({+ processBlock: function (words, offset) {+ this._cipher.encryptBlock(words, offset);+ }+ });++ ECB.Decryptor = ECB.extend({+ processBlock: function (words, offset) {+ this._cipher.decryptBlock(words, offset);+ }+ });++ return ECB;+ }());+++ return CryptoJS.mode.ECB;++}));+},{"./cipher-core":2,"./core":3}],16:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./cipher-core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./cipher-core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ /**+ * Output Feedback block mode.+ */+ CryptoJS.mode.OFB = (function () {+ var OFB = CryptoJS.lib.BlockCipherMode.extend();++ var Encryptor = OFB.Encryptor = OFB.extend({+ processBlock: function (words, offset) {+ // Shortcuts+ var cipher = this._cipher+ var blockSize = cipher.blockSize;+ var iv = this._iv;+ var keystream = this._keystream;++ // Generate keystream+ if (iv) {+ keystream = this._keystream = iv.slice(0);++ // Remove IV for subsequent blocks+ this._iv = undefined;+ }+ cipher.encryptBlock(keystream, 0);++ // Encrypt+ for (var i = 0; i < blockSize; i++) {+ words[offset + i] ^= keystream[i];+ }+ }+ });++ OFB.Decryptor = Encryptor;++ return OFB;+ }());+++ return CryptoJS.mode.OFB;++}));+},{"./cipher-core":2,"./core":3}],17:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./cipher-core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./cipher-core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ /**+ * ANSI X.923 padding strategy.+ */+ CryptoJS.pad.AnsiX923 = {+ pad: function (data, blockSize) {+ // Shortcuts+ var dataSigBytes = data.sigBytes;+ var blockSizeBytes = blockSize * 4;++ // Count padding bytes+ var nPaddingBytes = blockSizeBytes - dataSigBytes % blockSizeBytes;++ // Compute last byte position+ var lastBytePos = dataSigBytes + nPaddingBytes - 1;++ // Pad+ data.clamp();+ data.words[lastBytePos >>> 2] |= nPaddingBytes << (24 - (lastBytePos % 4) * 8);+ data.sigBytes += nPaddingBytes;+ },++ unpad: function (data) {+ // Get number of padding bytes from last byte+ var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;++ // Remove padding+ data.sigBytes -= nPaddingBytes;+ }+ };+++ return CryptoJS.pad.Ansix923;++}));+},{"./cipher-core":2,"./core":3}],18:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./cipher-core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./cipher-core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ /**+ * ISO 10126 padding strategy.+ */+ CryptoJS.pad.Iso10126 = {+ pad: function (data, blockSize) {+ // Shortcut+ var blockSizeBytes = blockSize * 4;++ // Count padding bytes+ var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;++ // Pad+ data.concat(CryptoJS.lib.WordArray.random(nPaddingBytes - 1)).+ concat(CryptoJS.lib.WordArray.create([nPaddingBytes << 24], 1));+ },++ unpad: function (data) {+ // Get number of padding bytes from last byte+ var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;++ // Remove padding+ data.sigBytes -= nPaddingBytes;+ }+ };+++ return CryptoJS.pad.Iso10126;++}));+},{"./cipher-core":2,"./core":3}],19:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./cipher-core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./cipher-core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ /**+ * ISO/IEC 9797-1 Padding Method 2.+ */+ CryptoJS.pad.Iso97971 = {+ pad: function (data, blockSize) {+ // Add 0x80 byte+ data.concat(CryptoJS.lib.WordArray.create([0x80000000], 1));++ // Zero pad the rest+ CryptoJS.pad.ZeroPadding.pad(data, blockSize);+ },++ unpad: function (data) {+ // Remove zero padding+ CryptoJS.pad.ZeroPadding.unpad(data);++ // Remove one more byte -- the 0x80 byte+ data.sigBytes--;+ }+ };+++ return CryptoJS.pad.Iso97971;++}));+},{"./cipher-core":2,"./core":3}],20:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./cipher-core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./cipher-core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ /**+ * A noop padding strategy.+ */+ CryptoJS.pad.NoPadding = {+ pad: function () {+ },++ unpad: function () {+ }+ };+++ return CryptoJS.pad.NoPadding;++}));+},{"./cipher-core":2,"./core":3}],21:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./cipher-core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./cipher-core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ /**+ * Zero padding strategy.+ */+ CryptoJS.pad.ZeroPadding = {+ pad: function (data, blockSize) {+ // Shortcut+ var blockSizeBytes = blockSize * 4;++ // Pad+ data.clamp();+ data.sigBytes += blockSizeBytes - ((data.sigBytes % blockSizeBytes) || blockSizeBytes);+ },++ unpad: function (data) {+ // Shortcut+ var dataWords = data.words;++ // Unpad+ var i = data.sigBytes - 1;+ while (!((dataWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff)) {+ i--;+ }+ data.sigBytes = i + 1;+ }+ };+++ return CryptoJS.pad.ZeroPadding;++}));+},{"./cipher-core":2,"./core":3}],22:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./sha1"), require("./hmac"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./sha1", "./hmac"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function () {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var Base = C_lib.Base;+ var WordArray = C_lib.WordArray;+ var C_algo = C.algo;+ var SHA1 = C_algo.SHA1;+ var HMAC = C_algo.HMAC;++ /**+ * Password-Based Key Derivation Function 2 algorithm.+ */+ var PBKDF2 = C_algo.PBKDF2 = Base.extend({+ /**+ * Configuration options.+ *+ * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)+ * @property {Hasher} hasher The hasher to use. Default: SHA1+ * @property {number} iterations The number of iterations to perform. Default: 1+ */+ cfg: Base.extend({+ keySize: 128/32,+ hasher: SHA1,+ iterations: 1+ }),++ /**+ * Initializes a newly created key derivation function.+ *+ * @param {Object} cfg (Optional) The configuration options to use for the derivation.+ *+ * @example+ *+ * var kdf = CryptoJS.algo.PBKDF2.create();+ * var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8 });+ * var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8, iterations: 1000 });+ */+ init: function (cfg) {+ this.cfg = this.cfg.extend(cfg);+ },++ /**+ * Computes the Password-Based Key Derivation Function 2.+ *+ * @param {WordArray|string} password The password.+ * @param {WordArray|string} salt A salt.+ *+ * @return {WordArray} The derived key.+ *+ * @example+ *+ * var key = kdf.compute(password, salt);+ */+ compute: function (password, salt) {+ // Shortcut+ var cfg = this.cfg;++ // Init HMAC+ var hmac = HMAC.create(cfg.hasher, password);++ // Initial values+ var derivedKey = WordArray.create();+ var blockIndex = WordArray.create([0x00000001]);++ // Shortcuts+ var derivedKeyWords = derivedKey.words;+ var blockIndexWords = blockIndex.words;+ var keySize = cfg.keySize;+ var iterations = cfg.iterations;++ // Generate key+ while (derivedKeyWords.length < keySize) {+ var block = hmac.update(salt).finalize(blockIndex);+ hmac.reset();++ // Shortcuts+ var blockWords = block.words;+ var blockWordsLength = blockWords.length;++ // Iterations+ var intermediate = block;+ for (var i = 1; i < iterations; i++) {+ intermediate = hmac.finalize(intermediate);+ hmac.reset();++ // Shortcut+ var intermediateWords = intermediate.words;++ // XOR intermediate with block+ for (var j = 0; j < blockWordsLength; j++) {+ blockWords[j] ^= intermediateWords[j];+ }+ }++ derivedKey.concat(block);+ blockIndexWords[0]++;+ }+ derivedKey.sigBytes = keySize * 4;++ return derivedKey;+ }+ });++ /**+ * Computes the Password-Based Key Derivation Function 2.+ *+ * @param {WordArray|string} password The password.+ * @param {WordArray|string} salt A salt.+ * @param {Object} cfg (Optional) The configuration options to use for this computation.+ *+ * @return {WordArray} The derived key.+ *+ * @static+ *+ * @example+ *+ * var key = CryptoJS.PBKDF2(password, salt);+ * var key = CryptoJS.PBKDF2(password, salt, { keySize: 8 });+ * var key = CryptoJS.PBKDF2(password, salt, { keySize: 8, iterations: 1000 });+ */+ C.PBKDF2 = function (password, salt, cfg) {+ return PBKDF2.create(cfg).compute(password, salt);+ };+ }());+++ return CryptoJS.PBKDF2;++}));+},{"./core":3,"./hmac":8,"./sha1":27}],23:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function () {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var StreamCipher = C_lib.StreamCipher;+ var C_algo = C.algo;++ // Reusable objects+ var S = [];+ var C_ = [];+ var G = [];++ /**+ * Rabbit stream cipher algorithm.+ *+ * This is a legacy version that neglected to convert the key to little-endian.+ * This error doesn't affect the cipher's security,+ * but it does affect its compatibility with other implementations.+ */+ var RabbitLegacy = C_algo.RabbitLegacy = StreamCipher.extend({+ _doReset: function () {+ // Shortcuts+ var K = this._key.words;+ var iv = this.cfg.iv;++ // Generate initial state values+ var X = this._X = [+ K[0], (K[3] << 16) | (K[2] >>> 16),+ K[1], (K[0] << 16) | (K[3] >>> 16),+ K[2], (K[1] << 16) | (K[0] >>> 16),+ K[3], (K[2] << 16) | (K[1] >>> 16)+ ];++ // Generate initial counter values+ var C = this._C = [+ (K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff),+ (K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff),+ (K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff),+ (K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff)+ ];++ // Carry bit+ this._b = 0;++ // Iterate the system four times+ for (var i = 0; i < 4; i++) {+ nextState.call(this);+ }++ // Modify the counters+ for (var i = 0; i < 8; i++) {+ C[i] ^= X[(i + 4) & 7];+ }++ // IV setup+ if (iv) {+ // Shortcuts+ var IV = iv.words;+ var IV_0 = IV[0];+ var IV_1 = IV[1];++ // Generate four subvectors+ var i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff) | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00);+ var i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff) | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00);+ var i1 = (i0 >>> 16) | (i2 & 0xffff0000);+ var i3 = (i2 << 16) | (i0 & 0x0000ffff);++ // Modify counter values+ C[0] ^= i0;+ C[1] ^= i1;+ C[2] ^= i2;+ C[3] ^= i3;+ C[4] ^= i0;+ C[5] ^= i1;+ C[6] ^= i2;+ C[7] ^= i3;++ // Iterate the system four times+ for (var i = 0; i < 4; i++) {+ nextState.call(this);+ }+ }+ },++ _doProcessBlock: function (M, offset) {+ // Shortcut+ var X = this._X;++ // Iterate the system+ nextState.call(this);++ // Generate four keystream words+ S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16);+ S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16);+ S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16);+ S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16);++ for (var i = 0; i < 4; i++) {+ // Swap endian+ S[i] = (((S[i] << 8) | (S[i] >>> 24)) & 0x00ff00ff) |+ (((S[i] << 24) | (S[i] >>> 8)) & 0xff00ff00);++ // Encrypt+ M[offset + i] ^= S[i];+ }+ },++ blockSize: 128/32,++ ivSize: 64/32+ });++ function nextState() {+ // Shortcuts+ var X = this._X;+ var C = this._C;++ // Save old counter values+ for (var i = 0; i < 8; i++) {+ C_[i] = C[i];+ }++ // Calculate new counter values+ C[0] = (C[0] + 0x4d34d34d + this._b) | 0;+ C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0;+ C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0;+ C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0;+ C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0;+ C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0;+ C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0;+ C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0;+ this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0;++ // Calculate the g-values+ for (var i = 0; i < 8; i++) {+ var gx = X[i] + C[i];++ // Construct high and low argument for squaring+ var ga = gx & 0xffff;+ var gb = gx >>> 16;++ // Calculate high and low result of squaring+ var gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb;+ var gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0);++ // High XOR low+ G[i] = gh ^ gl;+ }++ // Calculate new state values+ X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0;+ X[1] = (G[1] + ((G[0] << 8) | (G[0] >>> 24)) + G[7]) | 0;+ X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0;+ X[3] = (G[3] + ((G[2] << 8) | (G[2] >>> 24)) + G[1]) | 0;+ X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0;+ X[5] = (G[5] + ((G[4] << 8) | (G[4] >>> 24)) + G[3]) | 0;+ X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0;+ X[7] = (G[7] + ((G[6] << 8) | (G[6] >>> 24)) + G[5]) | 0;+ }++ /**+ * Shortcut functions to the cipher's object interface.+ *+ * @example+ *+ * var ciphertext = CryptoJS.RabbitLegacy.encrypt(message, key, cfg);+ * var plaintext = CryptoJS.RabbitLegacy.decrypt(ciphertext, key, cfg);+ */+ C.RabbitLegacy = StreamCipher._createHelper(RabbitLegacy);+ }());+++ return CryptoJS.RabbitLegacy;++}));+},{"./cipher-core":2,"./core":3,"./enc-base64":4,"./evpkdf":6,"./md5":11}],24:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function () {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var StreamCipher = C_lib.StreamCipher;+ var C_algo = C.algo;++ // Reusable objects+ var S = [];+ var C_ = [];+ var G = [];++ /**+ * Rabbit stream cipher algorithm+ */+ var Rabbit = C_algo.Rabbit = StreamCipher.extend({+ _doReset: function () {+ // Shortcuts+ var K = this._key.words;+ var iv = this.cfg.iv;++ // Swap endian+ for (var i = 0; i < 4; i++) {+ K[i] = (((K[i] << 8) | (K[i] >>> 24)) & 0x00ff00ff) |+ (((K[i] << 24) | (K[i] >>> 8)) & 0xff00ff00);+ }++ // Generate initial state values+ var X = this._X = [+ K[0], (K[3] << 16) | (K[2] >>> 16),+ K[1], (K[0] << 16) | (K[3] >>> 16),+ K[2], (K[1] << 16) | (K[0] >>> 16),+ K[3], (K[2] << 16) | (K[1] >>> 16)+ ];++ // Generate initial counter values+ var C = this._C = [+ (K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff),+ (K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff),+ (K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff),+ (K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff)+ ];++ // Carry bit+ this._b = 0;++ // Iterate the system four times+ for (var i = 0; i < 4; i++) {+ nextState.call(this);+ }++ // Modify the counters+ for (var i = 0; i < 8; i++) {+ C[i] ^= X[(i + 4) & 7];+ }++ // IV setup+ if (iv) {+ // Shortcuts+ var IV = iv.words;+ var IV_0 = IV[0];+ var IV_1 = IV[1];++ // Generate four subvectors+ var i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff) | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00);+ var i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff) | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00);+ var i1 = (i0 >>> 16) | (i2 & 0xffff0000);+ var i3 = (i2 << 16) | (i0 & 0x0000ffff);++ // Modify counter values+ C[0] ^= i0;+ C[1] ^= i1;+ C[2] ^= i2;+ C[3] ^= i3;+ C[4] ^= i0;+ C[5] ^= i1;+ C[6] ^= i2;+ C[7] ^= i3;++ // Iterate the system four times+ for (var i = 0; i < 4; i++) {+ nextState.call(this);+ }+ }+ },++ _doProcessBlock: function (M, offset) {+ // Shortcut+ var X = this._X;++ // Iterate the system+ nextState.call(this);++ // Generate four keystream words+ S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16);+ S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16);+ S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16);+ S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16);++ for (var i = 0; i < 4; i++) {+ // Swap endian+ S[i] = (((S[i] << 8) | (S[i] >>> 24)) & 0x00ff00ff) |+ (((S[i] << 24) | (S[i] >>> 8)) & 0xff00ff00);++ // Encrypt+ M[offset + i] ^= S[i];+ }+ },++ blockSize: 128/32,++ ivSize: 64/32+ });++ function nextState() {+ // Shortcuts+ var X = this._X;+ var C = this._C;++ // Save old counter values+ for (var i = 0; i < 8; i++) {+ C_[i] = C[i];+ }++ // Calculate new counter values+ C[0] = (C[0] + 0x4d34d34d + this._b) | 0;+ C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0;+ C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0;+ C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0;+ C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0;+ C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0;+ C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0;+ C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0;+ this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0;++ // Calculate the g-values+ for (var i = 0; i < 8; i++) {+ var gx = X[i] + C[i];++ // Construct high and low argument for squaring+ var ga = gx & 0xffff;+ var gb = gx >>> 16;++ // Calculate high and low result of squaring+ var gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb;+ var gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0);++ // High XOR low+ G[i] = gh ^ gl;+ }++ // Calculate new state values+ X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0;+ X[1] = (G[1] + ((G[0] << 8) | (G[0] >>> 24)) + G[7]) | 0;+ X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0;+ X[3] = (G[3] + ((G[2] << 8) | (G[2] >>> 24)) + G[1]) | 0;+ X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0;+ X[5] = (G[5] + ((G[4] << 8) | (G[4] >>> 24)) + G[3]) | 0;+ X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0;+ X[7] = (G[7] + ((G[6] << 8) | (G[6] >>> 24)) + G[5]) | 0;+ }++ /**+ * Shortcut functions to the cipher's object interface.+ *+ * @example+ *+ * var ciphertext = CryptoJS.Rabbit.encrypt(message, key, cfg);+ * var plaintext = CryptoJS.Rabbit.decrypt(ciphertext, key, cfg);+ */+ C.Rabbit = StreamCipher._createHelper(Rabbit);+ }());+++ return CryptoJS.Rabbit;++}));+},{"./cipher-core":2,"./core":3,"./enc-base64":4,"./evpkdf":6,"./md5":11}],25:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function () {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var StreamCipher = C_lib.StreamCipher;+ var C_algo = C.algo;++ /**+ * RC4 stream cipher algorithm.+ */+ var RC4 = C_algo.RC4 = StreamCipher.extend({+ _doReset: function () {+ // Shortcuts+ var key = this._key;+ var keyWords = key.words;+ var keySigBytes = key.sigBytes;++ // Init sbox+ var S = this._S = [];+ for (var i = 0; i < 256; i++) {+ S[i] = i;+ }++ // Key setup+ for (var i = 0, j = 0; i < 256; i++) {+ var keyByteIndex = i % keySigBytes;+ var keyByte = (keyWords[keyByteIndex >>> 2] >>> (24 - (keyByteIndex % 4) * 8)) & 0xff;++ j = (j + S[i] + keyByte) % 256;++ // Swap+ var t = S[i];+ S[i] = S[j];+ S[j] = t;+ }++ // Counters+ this._i = this._j = 0;+ },++ _doProcessBlock: function (M, offset) {+ M[offset] ^= generateKeystreamWord.call(this);+ },++ keySize: 256/32,++ ivSize: 0+ });++ function generateKeystreamWord() {+ // Shortcuts+ var S = this._S;+ var i = this._i;+ var j = this._j;++ // Generate keystream word+ var keystreamWord = 0;+ for (var n = 0; n < 4; n++) {+ i = (i + 1) % 256;+ j = (j + S[i]) % 256;++ // Swap+ var t = S[i];+ S[i] = S[j];+ S[j] = t;++ keystreamWord |= S[(S[i] + S[j]) % 256] << (24 - n * 8);+ }++ // Update counters+ this._i = i;+ this._j = j;++ return keystreamWord;+ }++ /**+ * Shortcut functions to the cipher's object interface.+ *+ * @example+ *+ * var ciphertext = CryptoJS.RC4.encrypt(message, key, cfg);+ * var plaintext = CryptoJS.RC4.decrypt(ciphertext, key, cfg);+ */+ C.RC4 = StreamCipher._createHelper(RC4);++ /**+ * Modified RC4 stream cipher algorithm.+ */+ var RC4Drop = C_algo.RC4Drop = RC4.extend({+ /**+ * Configuration options.+ *+ * @property {number} drop The number of keystream words to drop. Default 192+ */+ cfg: RC4.cfg.extend({+ drop: 192+ }),++ _doReset: function () {+ RC4._doReset.call(this);++ // Drop+ for (var i = this.cfg.drop; i > 0; i--) {+ generateKeystreamWord.call(this);+ }+ }+ });++ /**+ * Shortcut functions to the cipher's object interface.+ *+ * @example+ *+ * var ciphertext = CryptoJS.RC4Drop.encrypt(message, key, cfg);+ * var plaintext = CryptoJS.RC4Drop.decrypt(ciphertext, key, cfg);+ */+ C.RC4Drop = StreamCipher._createHelper(RC4Drop);+ }());+++ return CryptoJS.RC4;++}));+},{"./cipher-core":2,"./core":3,"./enc-base64":4,"./evpkdf":6,"./md5":11}],26:[function(require,module,exports){+;(function (root, factory) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ /** @preserve+ (c) 2012 by Cédric Mesnil. All rights reserved.++ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:++ - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.+ - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.++ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.+ */++ (function (Math) {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var WordArray = C_lib.WordArray;+ var Hasher = C_lib.Hasher;+ var C_algo = C.algo;++ // Constants table+ var _zl = WordArray.create([+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,+ 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,+ 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,+ 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,+ 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13]);+ var _zr = WordArray.create([+ 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,+ 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,+ 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,+ 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,+ 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11]);+ var _sl = WordArray.create([+ 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,+ 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,+ 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,+ 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,+ 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 ]);+ var _sr = WordArray.create([+ 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,+ 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,+ 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,+ 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,+ 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 ]);++ var _hl = WordArray.create([ 0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E]);+ var _hr = WordArray.create([ 0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000]);++ /**+ * RIPEMD160 hash algorithm.+ */+ var RIPEMD160 = C_algo.RIPEMD160 = Hasher.extend({+ _doReset: function () {+ this._hash = WordArray.create([0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0]);+ },++ _doProcessBlock: function (M, offset) {++ // Swap endian+ for (var i = 0; i < 16; i++) {+ // Shortcuts+ var offset_i = offset + i;+ var M_offset_i = M[offset_i];++ // Swap+ M[offset_i] = (+ (((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) |+ (((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00)+ );+ }+ // Shortcut+ var H = this._hash.words;+ var hl = _hl.words;+ var hr = _hr.words;+ var zl = _zl.words;+ var zr = _zr.words;+ var sl = _sl.words;+ var sr = _sr.words;++ // Working variables+ var al, bl, cl, dl, el;+ var ar, br, cr, dr, er;++ ar = al = H[0];+ br = bl = H[1];+ cr = cl = H[2];+ dr = dl = H[3];+ er = el = H[4];+ // Computation+ var t;+ for (var i = 0; i < 80; i += 1) {+ t = (al + M[offset+zl[i]])|0;+ if (i<16){+ t += f1(bl,cl,dl) + hl[0];+ } else if (i<32) {+ t += f2(bl,cl,dl) + hl[1];+ } else if (i<48) {+ t += f3(bl,cl,dl) + hl[2];+ } else if (i<64) {+ t += f4(bl,cl,dl) + hl[3];+ } else {// if (i<80) {+ t += f5(bl,cl,dl) + hl[4];+ }+ t = t|0;+ t = rotl(t,sl[i]);+ t = (t+el)|0;+ al = el;+ el = dl;+ dl = rotl(cl, 10);+ cl = bl;+ bl = t;++ t = (ar + M[offset+zr[i]])|0;+ if (i<16){+ t += f5(br,cr,dr) + hr[0];+ } else if (i<32) {+ t += f4(br,cr,dr) + hr[1];+ } else if (i<48) {+ t += f3(br,cr,dr) + hr[2];+ } else if (i<64) {+ t += f2(br,cr,dr) + hr[3];+ } else {// if (i<80) {+ t += f1(br,cr,dr) + hr[4];+ }+ t = t|0;+ t = rotl(t,sr[i]) ;+ t = (t+er)|0;+ ar = er;+ er = dr;+ dr = rotl(cr, 10);+ cr = br;+ br = t;+ }+ // Intermediate hash value+ t = (H[1] + cl + dr)|0;+ H[1] = (H[2] + dl + er)|0;+ H[2] = (H[3] + el + ar)|0;+ H[3] = (H[4] + al + br)|0;+ H[4] = (H[0] + bl + cr)|0;+ H[0] = t;+ },++ _doFinalize: function () {+ // Shortcuts+ var data = this._data;+ var dataWords = data.words;++ var nBitsTotal = this._nDataBytes * 8;+ var nBitsLeft = data.sigBytes * 8;++ // Add padding+ dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);+ dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (+ (((nBitsTotal << 8) | (nBitsTotal >>> 24)) & 0x00ff00ff) |+ (((nBitsTotal << 24) | (nBitsTotal >>> 8)) & 0xff00ff00)+ );+ data.sigBytes = (dataWords.length + 1) * 4;++ // Hash final blocks+ this._process();++ // Shortcuts+ var hash = this._hash;+ var H = hash.words;++ // Swap endian+ for (var i = 0; i < 5; i++) {+ // Shortcut+ var H_i = H[i];++ // Swap+ H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) |+ (((H_i << 24) | (H_i >>> 8)) & 0xff00ff00);+ }++ // Return final computed hash+ return hash;+ },++ clone: function () {+ var clone = Hasher.clone.call(this);+ clone._hash = this._hash.clone();++ return clone;+ }+ });+++ function f1(x, y, z) {+ return ((x) ^ (y) ^ (z));++ }++ function f2(x, y, z) {+ return (((x)&(y)) | ((~x)&(z)));+ }++ function f3(x, y, z) {+ return (((x) | (~(y))) ^ (z));+ }++ function f4(x, y, z) {+ return (((x) & (z)) | ((y)&(~(z))));+ }++ function f5(x, y, z) {+ return ((x) ^ ((y) |(~(z))));++ }++ function rotl(x,n) {+ return (x<<n) | (x>>>(32-n));+ }+++ /**+ * Shortcut function to the hasher's object interface.+ *+ * @param {WordArray|string} message The message to hash.+ *+ * @return {WordArray} The hash.+ *+ * @static+ *+ * @example+ *+ * var hash = CryptoJS.RIPEMD160('message');+ * var hash = CryptoJS.RIPEMD160(wordArray);+ */+ C.RIPEMD160 = Hasher._createHelper(RIPEMD160);++ /**+ * Shortcut function to the HMAC's object interface.+ *+ * @param {WordArray|string} message The message to hash.+ * @param {WordArray|string} key The secret key.+ *+ * @return {WordArray} The HMAC.+ *+ * @static+ *+ * @example+ *+ * var hmac = CryptoJS.HmacRIPEMD160(message, key);+ */+ C.HmacRIPEMD160 = Hasher._createHmacHelper(RIPEMD160);+ }(Math));+++ return CryptoJS.RIPEMD160;++}));+},{"./core":3}],27:[function(require,module,exports){+;(function (root, factory) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function () {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var WordArray = C_lib.WordArray;+ var Hasher = C_lib.Hasher;+ var C_algo = C.algo;++ // Reusable object+ var W = [];++ /**+ * SHA-1 hash algorithm.+ */+ var SHA1 = C_algo.SHA1 = Hasher.extend({+ _doReset: function () {+ this._hash = new WordArray.init([+ 0x67452301, 0xefcdab89,+ 0x98badcfe, 0x10325476,+ 0xc3d2e1f0+ ]);+ },++ _doProcessBlock: function (M, offset) {+ // Shortcut+ var H = this._hash.words;++ // Working variables+ var a = H[0];+ var b = H[1];+ var c = H[2];+ var d = H[3];+ var e = H[4];++ // Computation+ for (var i = 0; i < 80; i++) {+ if (i < 16) {+ W[i] = M[offset + i] | 0;+ } else {+ var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];+ W[i] = (n << 1) | (n >>> 31);+ }++ var t = ((a << 5) | (a >>> 27)) + e + W[i];+ if (i < 20) {+ t += ((b & c) | (~b & d)) + 0x5a827999;+ } else if (i < 40) {+ t += (b ^ c ^ d) + 0x6ed9eba1;+ } else if (i < 60) {+ t += ((b & c) | (b & d) | (c & d)) - 0x70e44324;+ } else /* if (i < 80) */ {+ t += (b ^ c ^ d) - 0x359d3e2a;+ }++ e = d;+ d = c;+ c = (b << 30) | (b >>> 2);+ b = a;+ a = t;+ }++ // Intermediate hash value+ H[0] = (H[0] + a) | 0;+ H[1] = (H[1] + b) | 0;+ H[2] = (H[2] + c) | 0;+ H[3] = (H[3] + d) | 0;+ H[4] = (H[4] + e) | 0;+ },++ _doFinalize: function () {+ // Shortcuts+ var data = this._data;+ var dataWords = data.words;++ var nBitsTotal = this._nDataBytes * 8;+ var nBitsLeft = data.sigBytes * 8;++ // Add padding+ dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);+ dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);+ dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;+ data.sigBytes = dataWords.length * 4;++ // Hash final blocks+ this._process();++ // Return final computed hash+ return this._hash;+ },++ clone: function () {+ var clone = Hasher.clone.call(this);+ clone._hash = this._hash.clone();++ return clone;+ }+ });++ /**+ * Shortcut function to the hasher's object interface.+ *+ * @param {WordArray|string} message The message to hash.+ *+ * @return {WordArray} The hash.+ *+ * @static+ *+ * @example+ *+ * var hash = CryptoJS.SHA1('message');+ * var hash = CryptoJS.SHA1(wordArray);+ */+ C.SHA1 = Hasher._createHelper(SHA1);++ /**+ * Shortcut function to the HMAC's object interface.+ *+ * @param {WordArray|string} message The message to hash.+ * @param {WordArray|string} key The secret key.+ *+ * @return {WordArray} The HMAC.+ *+ * @static+ *+ * @example+ *+ * var hmac = CryptoJS.HmacSHA1(message, key);+ */+ C.HmacSHA1 = Hasher._createHmacHelper(SHA1);+ }());+++ return CryptoJS.SHA1;++}));+},{"./core":3}],28:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./sha256"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./sha256"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function () {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var WordArray = C_lib.WordArray;+ var C_algo = C.algo;+ var SHA256 = C_algo.SHA256;++ /**+ * SHA-224 hash algorithm.+ */+ var SHA224 = C_algo.SHA224 = SHA256.extend({+ _doReset: function () {+ this._hash = new WordArray.init([+ 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,+ 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4+ ]);+ },++ _doFinalize: function () {+ var hash = SHA256._doFinalize.call(this);++ hash.sigBytes -= 4;++ return hash;+ }+ });++ /**+ * Shortcut function to the hasher's object interface.+ *+ * @param {WordArray|string} message The message to hash.+ *+ * @return {WordArray} The hash.+ *+ * @static+ *+ * @example+ *+ * var hash = CryptoJS.SHA224('message');+ * var hash = CryptoJS.SHA224(wordArray);+ */+ C.SHA224 = SHA256._createHelper(SHA224);++ /**+ * Shortcut function to the HMAC's object interface.+ *+ * @param {WordArray|string} message The message to hash.+ * @param {WordArray|string} key The secret key.+ *+ * @return {WordArray} The HMAC.+ *+ * @static+ *+ * @example+ *+ * var hmac = CryptoJS.HmacSHA224(message, key);+ */+ C.HmacSHA224 = SHA256._createHmacHelper(SHA224);+ }());+++ return CryptoJS.SHA224;++}));+},{"./core":3,"./sha256":29}],29:[function(require,module,exports){+;(function (root, factory) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function (Math) {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var WordArray = C_lib.WordArray;+ var Hasher = C_lib.Hasher;+ var C_algo = C.algo;++ // Initialization and round constants tables+ var H = [];+ var K = [];++ // Compute constants+ (function () {+ function isPrime(n) {+ var sqrtN = Math.sqrt(n);+ for (var factor = 2; factor <= sqrtN; factor++) {+ if (!(n % factor)) {+ return false;+ }+ }++ return true;+ }++ function getFractionalBits(n) {+ return ((n - (n | 0)) * 0x100000000) | 0;+ }++ var n = 2;+ var nPrime = 0;+ while (nPrime < 64) {+ if (isPrime(n)) {+ if (nPrime < 8) {+ H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2));+ }+ K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3));++ nPrime++;+ }++ n++;+ }+ }());++ // Reusable object+ var W = [];++ /**+ * SHA-256 hash algorithm.+ */+ var SHA256 = C_algo.SHA256 = Hasher.extend({+ _doReset: function () {+ this._hash = new WordArray.init(H.slice(0));+ },++ _doProcessBlock: function (M, offset) {+ // Shortcut+ var H = this._hash.words;++ // Working variables+ var a = H[0];+ var b = H[1];+ var c = H[2];+ var d = H[3];+ var e = H[4];+ var f = H[5];+ var g = H[6];+ var h = H[7];++ // Computation+ for (var i = 0; i < 64; i++) {+ if (i < 16) {+ W[i] = M[offset + i] | 0;+ } else {+ var gamma0x = W[i - 15];+ var gamma0 = ((gamma0x << 25) | (gamma0x >>> 7)) ^+ ((gamma0x << 14) | (gamma0x >>> 18)) ^+ (gamma0x >>> 3);++ var gamma1x = W[i - 2];+ var gamma1 = ((gamma1x << 15) | (gamma1x >>> 17)) ^+ ((gamma1x << 13) | (gamma1x >>> 19)) ^+ (gamma1x >>> 10);++ W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];+ }++ var ch = (e & f) ^ (~e & g);+ var maj = (a & b) ^ (a & c) ^ (b & c);++ var sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22));+ var sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7) | (e >>> 25));++ var t1 = h + sigma1 + ch + K[i] + W[i];+ var t2 = sigma0 + maj;++ h = g;+ g = f;+ f = e;+ e = (d + t1) | 0;+ d = c;+ c = b;+ b = a;+ a = (t1 + t2) | 0;+ }++ // Intermediate hash value+ H[0] = (H[0] + a) | 0;+ H[1] = (H[1] + b) | 0;+ H[2] = (H[2] + c) | 0;+ H[3] = (H[3] + d) | 0;+ H[4] = (H[4] + e) | 0;+ H[5] = (H[5] + f) | 0;+ H[6] = (H[6] + g) | 0;+ H[7] = (H[7] + h) | 0;+ },++ _doFinalize: function () {+ // Shortcuts+ var data = this._data;+ var dataWords = data.words;++ var nBitsTotal = this._nDataBytes * 8;+ var nBitsLeft = data.sigBytes * 8;++ // Add padding+ dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);+ dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);+ dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;+ data.sigBytes = dataWords.length * 4;++ // Hash final blocks+ this._process();++ // Return final computed hash+ return this._hash;+ },++ clone: function () {+ var clone = Hasher.clone.call(this);+ clone._hash = this._hash.clone();++ return clone;+ }+ });++ /**+ * Shortcut function to the hasher's object interface.+ *+ * @param {WordArray|string} message The message to hash.+ *+ * @return {WordArray} The hash.+ *+ * @static+ *+ * @example+ *+ * var hash = CryptoJS.SHA256('message');+ * var hash = CryptoJS.SHA256(wordArray);+ */+ C.SHA256 = Hasher._createHelper(SHA256);++ /**+ * Shortcut function to the HMAC's object interface.+ *+ * @param {WordArray|string} message The message to hash.+ * @param {WordArray|string} key The secret key.+ *+ * @return {WordArray} The HMAC.+ *+ * @static+ *+ * @example+ *+ * var hmac = CryptoJS.HmacSHA256(message, key);+ */+ C.HmacSHA256 = Hasher._createHmacHelper(SHA256);+ }(Math));+++ return CryptoJS.SHA256;++}));+},{"./core":3}],30:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./x64-core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./x64-core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function (Math) {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var WordArray = C_lib.WordArray;+ var Hasher = C_lib.Hasher;+ var C_x64 = C.x64;+ var X64Word = C_x64.Word;+ var C_algo = C.algo;++ // Constants tables+ var RHO_OFFSETS = [];+ var PI_INDEXES = [];+ var ROUND_CONSTANTS = [];++ // Compute Constants+ (function () {+ // Compute rho offset constants+ var x = 1, y = 0;+ for (var t = 0; t < 24; t++) {+ RHO_OFFSETS[x + 5 * y] = ((t + 1) * (t + 2) / 2) % 64;++ var newX = y % 5;+ var newY = (2 * x + 3 * y) % 5;+ x = newX;+ y = newY;+ }++ // Compute pi index constants+ for (var x = 0; x < 5; x++) {+ for (var y = 0; y < 5; y++) {+ PI_INDEXES[x + 5 * y] = y + ((2 * x + 3 * y) % 5) * 5;+ }+ }++ // Compute round constants+ var LFSR = 0x01;+ for (var i = 0; i < 24; i++) {+ var roundConstantMsw = 0;+ var roundConstantLsw = 0;++ for (var j = 0; j < 7; j++) {+ if (LFSR & 0x01) {+ var bitPosition = (1 << j) - 1;+ if (bitPosition < 32) {+ roundConstantLsw ^= 1 << bitPosition;+ } else /* if (bitPosition >= 32) */ {+ roundConstantMsw ^= 1 << (bitPosition - 32);+ }+ }++ // Compute next LFSR+ if (LFSR & 0x80) {+ // Primitive polynomial over GF(2): x^8 + x^6 + x^5 + x^4 + 1+ LFSR = (LFSR << 1) ^ 0x71;+ } else {+ LFSR <<= 1;+ }+ }++ ROUND_CONSTANTS[i] = X64Word.create(roundConstantMsw, roundConstantLsw);+ }+ }());++ // Reusable objects for temporary values+ var T = [];+ (function () {+ for (var i = 0; i < 25; i++) {+ T[i] = X64Word.create();+ }+ }());++ /**+ * SHA-3 hash algorithm.+ */+ var SHA3 = C_algo.SHA3 = Hasher.extend({+ /**+ * Configuration options.+ *+ * @property {number} outputLength+ * The desired number of bits in the output hash.+ * Only values permitted are: 224, 256, 384, 512.+ * Default: 512+ */+ cfg: Hasher.cfg.extend({+ outputLength: 512+ }),++ _doReset: function () {+ var state = this._state = []+ for (var i = 0; i < 25; i++) {+ state[i] = new X64Word.init();+ }++ this.blockSize = (1600 - 2 * this.cfg.outputLength) / 32;+ },++ _doProcessBlock: function (M, offset) {+ // Shortcuts+ var state = this._state;+ var nBlockSizeLanes = this.blockSize / 2;++ // Absorb+ for (var i = 0; i < nBlockSizeLanes; i++) {+ // Shortcuts+ var M2i = M[offset + 2 * i];+ var M2i1 = M[offset + 2 * i + 1];++ // Swap endian+ M2i = (+ (((M2i << 8) | (M2i >>> 24)) & 0x00ff00ff) |+ (((M2i << 24) | (M2i >>> 8)) & 0xff00ff00)+ );+ M2i1 = (+ (((M2i1 << 8) | (M2i1 >>> 24)) & 0x00ff00ff) |+ (((M2i1 << 24) | (M2i1 >>> 8)) & 0xff00ff00)+ );++ // Absorb message into state+ var lane = state[i];+ lane.high ^= M2i1;+ lane.low ^= M2i;+ }++ // Rounds+ for (var round = 0; round < 24; round++) {+ // Theta+ for (var x = 0; x < 5; x++) {+ // Mix column lanes+ var tMsw = 0, tLsw = 0;+ for (var y = 0; y < 5; y++) {+ var lane = state[x + 5 * y];+ tMsw ^= lane.high;+ tLsw ^= lane.low;+ }++ // Temporary values+ var Tx = T[x];+ Tx.high = tMsw;+ Tx.low = tLsw;+ }+ for (var x = 0; x < 5; x++) {+ // Shortcuts+ var Tx4 = T[(x + 4) % 5];+ var Tx1 = T[(x + 1) % 5];+ var Tx1Msw = Tx1.high;+ var Tx1Lsw = Tx1.low;++ // Mix surrounding columns+ var tMsw = Tx4.high ^ ((Tx1Msw << 1) | (Tx1Lsw >>> 31));+ var tLsw = Tx4.low ^ ((Tx1Lsw << 1) | (Tx1Msw >>> 31));+ for (var y = 0; y < 5; y++) {+ var lane = state[x + 5 * y];+ lane.high ^= tMsw;+ lane.low ^= tLsw;+ }+ }++ // Rho Pi+ for (var laneIndex = 1; laneIndex < 25; laneIndex++) {+ // Shortcuts+ var lane = state[laneIndex];+ var laneMsw = lane.high;+ var laneLsw = lane.low;+ var rhoOffset = RHO_OFFSETS[laneIndex];++ // Rotate lanes+ if (rhoOffset < 32) {+ var tMsw = (laneMsw << rhoOffset) | (laneLsw >>> (32 - rhoOffset));+ var tLsw = (laneLsw << rhoOffset) | (laneMsw >>> (32 - rhoOffset));+ } else /* if (rhoOffset >= 32) */ {+ var tMsw = (laneLsw << (rhoOffset - 32)) | (laneMsw >>> (64 - rhoOffset));+ var tLsw = (laneMsw << (rhoOffset - 32)) | (laneLsw >>> (64 - rhoOffset));+ }++ // Transpose lanes+ var TPiLane = T[PI_INDEXES[laneIndex]];+ TPiLane.high = tMsw;+ TPiLane.low = tLsw;+ }++ // Rho pi at x = y = 0+ var T0 = T[0];+ var state0 = state[0];+ T0.high = state0.high;+ T0.low = state0.low;++ // Chi+ for (var x = 0; x < 5; x++) {+ for (var y = 0; y < 5; y++) {+ // Shortcuts+ var laneIndex = x + 5 * y;+ var lane = state[laneIndex];+ var TLane = T[laneIndex];+ var Tx1Lane = T[((x + 1) % 5) + 5 * y];+ var Tx2Lane = T[((x + 2) % 5) + 5 * y];++ // Mix rows+ lane.high = TLane.high ^ (~Tx1Lane.high & Tx2Lane.high);+ lane.low = TLane.low ^ (~Tx1Lane.low & Tx2Lane.low);+ }+ }++ // Iota+ var lane = state[0];+ var roundConstant = ROUND_CONSTANTS[round];+ lane.high ^= roundConstant.high;+ lane.low ^= roundConstant.low;;+ }+ },++ _doFinalize: function () {+ // Shortcuts+ var data = this._data;+ var dataWords = data.words;+ var nBitsTotal = this._nDataBytes * 8;+ var nBitsLeft = data.sigBytes * 8;+ var blockSizeBits = this.blockSize * 32;++ // Add padding+ dataWords[nBitsLeft >>> 5] |= 0x1 << (24 - nBitsLeft % 32);+ dataWords[((Math.ceil((nBitsLeft + 1) / blockSizeBits) * blockSizeBits) >>> 5) - 1] |= 0x80;+ data.sigBytes = dataWords.length * 4;++ // Hash final blocks+ this._process();++ // Shortcuts+ var state = this._state;+ var outputLengthBytes = this.cfg.outputLength / 8;+ var outputLengthLanes = outputLengthBytes / 8;++ // Squeeze+ var hashWords = [];+ for (var i = 0; i < outputLengthLanes; i++) {+ // Shortcuts+ var lane = state[i];+ var laneMsw = lane.high;+ var laneLsw = lane.low;++ // Swap endian+ laneMsw = (+ (((laneMsw << 8) | (laneMsw >>> 24)) & 0x00ff00ff) |+ (((laneMsw << 24) | (laneMsw >>> 8)) & 0xff00ff00)+ );+ laneLsw = (+ (((laneLsw << 8) | (laneLsw >>> 24)) & 0x00ff00ff) |+ (((laneLsw << 24) | (laneLsw >>> 8)) & 0xff00ff00)+ );++ // Squeeze state to retrieve hash+ hashWords.push(laneLsw);+ hashWords.push(laneMsw);+ }++ // Return final computed hash+ return new WordArray.init(hashWords, outputLengthBytes);+ },++ clone: function () {+ var clone = Hasher.clone.call(this);++ var state = clone._state = this._state.slice(0);+ for (var i = 0; i < 25; i++) {+ state[i] = state[i].clone();+ }++ return clone;+ }+ });++ /**+ * Shortcut function to the hasher's object interface.+ *+ * @param {WordArray|string} message The message to hash.+ *+ * @return {WordArray} The hash.+ *+ * @static+ *+ * @example+ *+ * var hash = CryptoJS.SHA3('message');+ * var hash = CryptoJS.SHA3(wordArray);+ */+ C.SHA3 = Hasher._createHelper(SHA3);++ /**+ * Shortcut function to the HMAC's object interface.+ *+ * @param {WordArray|string} message The message to hash.+ * @param {WordArray|string} key The secret key.+ *+ * @return {WordArray} The HMAC.+ *+ * @static+ *+ * @example+ *+ * var hmac = CryptoJS.HmacSHA3(message, key);+ */+ C.HmacSHA3 = Hasher._createHmacHelper(SHA3);+ }(Math));+++ return CryptoJS.SHA3;++}));+},{"./core":3,"./x64-core":34}],31:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./x64-core"), require("./sha512"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./x64-core", "./sha512"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function () {+ // Shortcuts+ var C = CryptoJS;+ var C_x64 = C.x64;+ var X64Word = C_x64.Word;+ var X64WordArray = C_x64.WordArray;+ var C_algo = C.algo;+ var SHA512 = C_algo.SHA512;++ /**+ * SHA-384 hash algorithm.+ */+ var SHA384 = C_algo.SHA384 = SHA512.extend({+ _doReset: function () {+ this._hash = new X64WordArray.init([+ new X64Word.init(0xcbbb9d5d, 0xc1059ed8), new X64Word.init(0x629a292a, 0x367cd507),+ new X64Word.init(0x9159015a, 0x3070dd17), new X64Word.init(0x152fecd8, 0xf70e5939),+ new X64Word.init(0x67332667, 0xffc00b31), new X64Word.init(0x8eb44a87, 0x68581511),+ new X64Word.init(0xdb0c2e0d, 0x64f98fa7), new X64Word.init(0x47b5481d, 0xbefa4fa4)+ ]);+ },++ _doFinalize: function () {+ var hash = SHA512._doFinalize.call(this);++ hash.sigBytes -= 16;++ return hash;+ }+ });++ /**+ * Shortcut function to the hasher's object interface.+ *+ * @param {WordArray|string} message The message to hash.+ *+ * @return {WordArray} The hash.+ *+ * @static+ *+ * @example+ *+ * var hash = CryptoJS.SHA384('message');+ * var hash = CryptoJS.SHA384(wordArray);+ */+ C.SHA384 = SHA512._createHelper(SHA384);++ /**+ * Shortcut function to the HMAC's object interface.+ *+ * @param {WordArray|string} message The message to hash.+ * @param {WordArray|string} key The secret key.+ *+ * @return {WordArray} The HMAC.+ *+ * @static+ *+ * @example+ *+ * var hmac = CryptoJS.HmacSHA384(message, key);+ */+ C.HmacSHA384 = SHA512._createHmacHelper(SHA384);+ }());+++ return CryptoJS.SHA384;++}));+},{"./core":3,"./sha512":32,"./x64-core":34}],32:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./x64-core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./x64-core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function () {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var Hasher = C_lib.Hasher;+ var C_x64 = C.x64;+ var X64Word = C_x64.Word;+ var X64WordArray = C_x64.WordArray;+ var C_algo = C.algo;++ function X64Word_create() {+ return X64Word.create.apply(X64Word, arguments);+ }++ // Constants+ var K = [+ X64Word_create(0x428a2f98, 0xd728ae22), X64Word_create(0x71374491, 0x23ef65cd),+ X64Word_create(0xb5c0fbcf, 0xec4d3b2f), X64Word_create(0xe9b5dba5, 0x8189dbbc),+ X64Word_create(0x3956c25b, 0xf348b538), X64Word_create(0x59f111f1, 0xb605d019),+ X64Word_create(0x923f82a4, 0xaf194f9b), X64Word_create(0xab1c5ed5, 0xda6d8118),+ X64Word_create(0xd807aa98, 0xa3030242), X64Word_create(0x12835b01, 0x45706fbe),+ X64Word_create(0x243185be, 0x4ee4b28c), X64Word_create(0x550c7dc3, 0xd5ffb4e2),+ X64Word_create(0x72be5d74, 0xf27b896f), X64Word_create(0x80deb1fe, 0x3b1696b1),+ X64Word_create(0x9bdc06a7, 0x25c71235), X64Word_create(0xc19bf174, 0xcf692694),+ X64Word_create(0xe49b69c1, 0x9ef14ad2), X64Word_create(0xefbe4786, 0x384f25e3),+ X64Word_create(0x0fc19dc6, 0x8b8cd5b5), X64Word_create(0x240ca1cc, 0x77ac9c65),+ X64Word_create(0x2de92c6f, 0x592b0275), X64Word_create(0x4a7484aa, 0x6ea6e483),+ X64Word_create(0x5cb0a9dc, 0xbd41fbd4), X64Word_create(0x76f988da, 0x831153b5),+ X64Word_create(0x983e5152, 0xee66dfab), X64Word_create(0xa831c66d, 0x2db43210),+ X64Word_create(0xb00327c8, 0x98fb213f), X64Word_create(0xbf597fc7, 0xbeef0ee4),+ X64Word_create(0xc6e00bf3, 0x3da88fc2), X64Word_create(0xd5a79147, 0x930aa725),+ X64Word_create(0x06ca6351, 0xe003826f), X64Word_create(0x14292967, 0x0a0e6e70),+ X64Word_create(0x27b70a85, 0x46d22ffc), X64Word_create(0x2e1b2138, 0x5c26c926),+ X64Word_create(0x4d2c6dfc, 0x5ac42aed), X64Word_create(0x53380d13, 0x9d95b3df),+ X64Word_create(0x650a7354, 0x8baf63de), X64Word_create(0x766a0abb, 0x3c77b2a8),+ X64Word_create(0x81c2c92e, 0x47edaee6), X64Word_create(0x92722c85, 0x1482353b),+ X64Word_create(0xa2bfe8a1, 0x4cf10364), X64Word_create(0xa81a664b, 0xbc423001),+ X64Word_create(0xc24b8b70, 0xd0f89791), X64Word_create(0xc76c51a3, 0x0654be30),+ X64Word_create(0xd192e819, 0xd6ef5218), X64Word_create(0xd6990624, 0x5565a910),+ X64Word_create(0xf40e3585, 0x5771202a), X64Word_create(0x106aa070, 0x32bbd1b8),+ X64Word_create(0x19a4c116, 0xb8d2d0c8), X64Word_create(0x1e376c08, 0x5141ab53),+ X64Word_create(0x2748774c, 0xdf8eeb99), X64Word_create(0x34b0bcb5, 0xe19b48a8),+ X64Word_create(0x391c0cb3, 0xc5c95a63), X64Word_create(0x4ed8aa4a, 0xe3418acb),+ X64Word_create(0x5b9cca4f, 0x7763e373), X64Word_create(0x682e6ff3, 0xd6b2b8a3),+ X64Word_create(0x748f82ee, 0x5defb2fc), X64Word_create(0x78a5636f, 0x43172f60),+ X64Word_create(0x84c87814, 0xa1f0ab72), X64Word_create(0x8cc70208, 0x1a6439ec),+ X64Word_create(0x90befffa, 0x23631e28), X64Word_create(0xa4506ceb, 0xde82bde9),+ X64Word_create(0xbef9a3f7, 0xb2c67915), X64Word_create(0xc67178f2, 0xe372532b),+ X64Word_create(0xca273ece, 0xea26619c), X64Word_create(0xd186b8c7, 0x21c0c207),+ X64Word_create(0xeada7dd6, 0xcde0eb1e), X64Word_create(0xf57d4f7f, 0xee6ed178),+ X64Word_create(0x06f067aa, 0x72176fba), X64Word_create(0x0a637dc5, 0xa2c898a6),+ X64Word_create(0x113f9804, 0xbef90dae), X64Word_create(0x1b710b35, 0x131c471b),+ X64Word_create(0x28db77f5, 0x23047d84), X64Word_create(0x32caab7b, 0x40c72493),+ X64Word_create(0x3c9ebe0a, 0x15c9bebc), X64Word_create(0x431d67c4, 0x9c100d4c),+ X64Word_create(0x4cc5d4be, 0xcb3e42b6), X64Word_create(0x597f299c, 0xfc657e2a),+ X64Word_create(0x5fcb6fab, 0x3ad6faec), X64Word_create(0x6c44198c, 0x4a475817)+ ];++ // Reusable objects+ var W = [];+ (function () {+ for (var i = 0; i < 80; i++) {+ W[i] = X64Word_create();+ }+ }());++ /**+ * SHA-512 hash algorithm.+ */+ var SHA512 = C_algo.SHA512 = Hasher.extend({+ _doReset: function () {+ this._hash = new X64WordArray.init([+ new X64Word.init(0x6a09e667, 0xf3bcc908), new X64Word.init(0xbb67ae85, 0x84caa73b),+ new X64Word.init(0x3c6ef372, 0xfe94f82b), new X64Word.init(0xa54ff53a, 0x5f1d36f1),+ new X64Word.init(0x510e527f, 0xade682d1), new X64Word.init(0x9b05688c, 0x2b3e6c1f),+ new X64Word.init(0x1f83d9ab, 0xfb41bd6b), new X64Word.init(0x5be0cd19, 0x137e2179)+ ]);+ },++ _doProcessBlock: function (M, offset) {+ // Shortcuts+ var H = this._hash.words;++ var H0 = H[0];+ var H1 = H[1];+ var H2 = H[2];+ var H3 = H[3];+ var H4 = H[4];+ var H5 = H[5];+ var H6 = H[6];+ var H7 = H[7];++ var H0h = H0.high;+ var H0l = H0.low;+ var H1h = H1.high;+ var H1l = H1.low;+ var H2h = H2.high;+ var H2l = H2.low;+ var H3h = H3.high;+ var H3l = H3.low;+ var H4h = H4.high;+ var H4l = H4.low;+ var H5h = H5.high;+ var H5l = H5.low;+ var H6h = H6.high;+ var H6l = H6.low;+ var H7h = H7.high;+ var H7l = H7.low;++ // Working variables+ var ah = H0h;+ var al = H0l;+ var bh = H1h;+ var bl = H1l;+ var ch = H2h;+ var cl = H2l;+ var dh = H3h;+ var dl = H3l;+ var eh = H4h;+ var el = H4l;+ var fh = H5h;+ var fl = H5l;+ var gh = H6h;+ var gl = H6l;+ var hh = H7h;+ var hl = H7l;++ // Rounds+ for (var i = 0; i < 80; i++) {+ // Shortcut+ var Wi = W[i];++ // Extend message+ if (i < 16) {+ var Wih = Wi.high = M[offset + i * 2] | 0;+ var Wil = Wi.low = M[offset + i * 2 + 1] | 0;+ } else {+ // Gamma0+ var gamma0x = W[i - 15];+ var gamma0xh = gamma0x.high;+ var gamma0xl = gamma0x.low;+ var gamma0h = ((gamma0xh >>> 1) | (gamma0xl << 31)) ^ ((gamma0xh >>> 8) | (gamma0xl << 24)) ^ (gamma0xh >>> 7);+ var gamma0l = ((gamma0xl >>> 1) | (gamma0xh << 31)) ^ ((gamma0xl >>> 8) | (gamma0xh << 24)) ^ ((gamma0xl >>> 7) | (gamma0xh << 25));++ // Gamma1+ var gamma1x = W[i - 2];+ var gamma1xh = gamma1x.high;+ var gamma1xl = gamma1x.low;+ var gamma1h = ((gamma1xh >>> 19) | (gamma1xl << 13)) ^ ((gamma1xh << 3) | (gamma1xl >>> 29)) ^ (gamma1xh >>> 6);+ var gamma1l = ((gamma1xl >>> 19) | (gamma1xh << 13)) ^ ((gamma1xl << 3) | (gamma1xh >>> 29)) ^ ((gamma1xl >>> 6) | (gamma1xh << 26));++ // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]+ var Wi7 = W[i - 7];+ var Wi7h = Wi7.high;+ var Wi7l = Wi7.low;++ var Wi16 = W[i - 16];+ var Wi16h = Wi16.high;+ var Wi16l = Wi16.low;++ var Wil = gamma0l + Wi7l;+ var Wih = gamma0h + Wi7h + ((Wil >>> 0) < (gamma0l >>> 0) ? 1 : 0);+ var Wil = Wil + gamma1l;+ var Wih = Wih + gamma1h + ((Wil >>> 0) < (gamma1l >>> 0) ? 1 : 0);+ var Wil = Wil + Wi16l;+ var Wih = Wih + Wi16h + ((Wil >>> 0) < (Wi16l >>> 0) ? 1 : 0);++ Wi.high = Wih;+ Wi.low = Wil;+ }++ var chh = (eh & fh) ^ (~eh & gh);+ var chl = (el & fl) ^ (~el & gl);+ var majh = (ah & bh) ^ (ah & ch) ^ (bh & ch);+ var majl = (al & bl) ^ (al & cl) ^ (bl & cl);++ var sigma0h = ((ah >>> 28) | (al << 4)) ^ ((ah << 30) | (al >>> 2)) ^ ((ah << 25) | (al >>> 7));+ var sigma0l = ((al >>> 28) | (ah << 4)) ^ ((al << 30) | (ah >>> 2)) ^ ((al << 25) | (ah >>> 7));+ var sigma1h = ((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9));+ var sigma1l = ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9));++ // t1 = h + sigma1 + ch + K[i] + W[i]+ var Ki = K[i];+ var Kih = Ki.high;+ var Kil = Ki.low;++ var t1l = hl + sigma1l;+ var t1h = hh + sigma1h + ((t1l >>> 0) < (hl >>> 0) ? 1 : 0);+ var t1l = t1l + chl;+ var t1h = t1h + chh + ((t1l >>> 0) < (chl >>> 0) ? 1 : 0);+ var t1l = t1l + Kil;+ var t1h = t1h + Kih + ((t1l >>> 0) < (Kil >>> 0) ? 1 : 0);+ var t1l = t1l + Wil;+ var t1h = t1h + Wih + ((t1l >>> 0) < (Wil >>> 0) ? 1 : 0);++ // t2 = sigma0 + maj+ var t2l = sigma0l + majl;+ var t2h = sigma0h + majh + ((t2l >>> 0) < (sigma0l >>> 0) ? 1 : 0);++ // Update working variables+ hh = gh;+ hl = gl;+ gh = fh;+ gl = fl;+ fh = eh;+ fl = el;+ el = (dl + t1l) | 0;+ eh = (dh + t1h + ((el >>> 0) < (dl >>> 0) ? 1 : 0)) | 0;+ dh = ch;+ dl = cl;+ ch = bh;+ cl = bl;+ bh = ah;+ bl = al;+ al = (t1l + t2l) | 0;+ ah = (t1h + t2h + ((al >>> 0) < (t1l >>> 0) ? 1 : 0)) | 0;+ }++ // Intermediate hash value+ H0l = H0.low = (H0l + al);+ H0.high = (H0h + ah + ((H0l >>> 0) < (al >>> 0) ? 1 : 0));+ H1l = H1.low = (H1l + bl);+ H1.high = (H1h + bh + ((H1l >>> 0) < (bl >>> 0) ? 1 : 0));+ H2l = H2.low = (H2l + cl);+ H2.high = (H2h + ch + ((H2l >>> 0) < (cl >>> 0) ? 1 : 0));+ H3l = H3.low = (H3l + dl);+ H3.high = (H3h + dh + ((H3l >>> 0) < (dl >>> 0) ? 1 : 0));+ H4l = H4.low = (H4l + el);+ H4.high = (H4h + eh + ((H4l >>> 0) < (el >>> 0) ? 1 : 0));+ H5l = H5.low = (H5l + fl);+ H5.high = (H5h + fh + ((H5l >>> 0) < (fl >>> 0) ? 1 : 0));+ H6l = H6.low = (H6l + gl);+ H6.high = (H6h + gh + ((H6l >>> 0) < (gl >>> 0) ? 1 : 0));+ H7l = H7.low = (H7l + hl);+ H7.high = (H7h + hh + ((H7l >>> 0) < (hl >>> 0) ? 1 : 0));+ },++ _doFinalize: function () {+ // Shortcuts+ var data = this._data;+ var dataWords = data.words;++ var nBitsTotal = this._nDataBytes * 8;+ var nBitsLeft = data.sigBytes * 8;++ // Add padding+ dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);+ dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 30] = Math.floor(nBitsTotal / 0x100000000);+ dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 31] = nBitsTotal;+ data.sigBytes = dataWords.length * 4;++ // Hash final blocks+ this._process();++ // Convert hash to 32-bit word array before returning+ var hash = this._hash.toX32();++ // Return final computed hash+ return hash;+ },++ clone: function () {+ var clone = Hasher.clone.call(this);+ clone._hash = this._hash.clone();++ return clone;+ },++ blockSize: 1024/32+ });++ /**+ * Shortcut function to the hasher's object interface.+ *+ * @param {WordArray|string} message The message to hash.+ *+ * @return {WordArray} The hash.+ *+ * @static+ *+ * @example+ *+ * var hash = CryptoJS.SHA512('message');+ * var hash = CryptoJS.SHA512(wordArray);+ */+ C.SHA512 = Hasher._createHelper(SHA512);++ /**+ * Shortcut function to the HMAC's object interface.+ *+ * @param {WordArray|string} message The message to hash.+ * @param {WordArray|string} key The secret key.+ *+ * @return {WordArray} The HMAC.+ *+ * @static+ *+ * @example+ *+ * var hmac = CryptoJS.HmacSHA512(message, key);+ */+ C.HmacSHA512 = Hasher._createHmacHelper(SHA512);+ }());+++ return CryptoJS.SHA512;++}));+},{"./core":3,"./x64-core":34}],33:[function(require,module,exports){+;(function (root, factory, undef) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function () {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var WordArray = C_lib.WordArray;+ var BlockCipher = C_lib.BlockCipher;+ var C_algo = C.algo;++ // Permuted Choice 1 constants+ var PC1 = [+ 57, 49, 41, 33, 25, 17, 9, 1,+ 58, 50, 42, 34, 26, 18, 10, 2,+ 59, 51, 43, 35, 27, 19, 11, 3,+ 60, 52, 44, 36, 63, 55, 47, 39,+ 31, 23, 15, 7, 62, 54, 46, 38,+ 30, 22, 14, 6, 61, 53, 45, 37,+ 29, 21, 13, 5, 28, 20, 12, 4+ ];++ // Permuted Choice 2 constants+ var PC2 = [+ 14, 17, 11, 24, 1, 5,+ 3, 28, 15, 6, 21, 10,+ 23, 19, 12, 4, 26, 8,+ 16, 7, 27, 20, 13, 2,+ 41, 52, 31, 37, 47, 55,+ 30, 40, 51, 45, 33, 48,+ 44, 49, 39, 56, 34, 53,+ 46, 42, 50, 36, 29, 32+ ];++ // Cumulative bit shift constants+ var BIT_SHIFTS = [1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28];++ // SBOXes and round permutation constants+ var SBOX_P = [+ {+ 0x0: 0x808200,+ 0x10000000: 0x8000,+ 0x20000000: 0x808002,+ 0x30000000: 0x2,+ 0x40000000: 0x200,+ 0x50000000: 0x808202,+ 0x60000000: 0x800202,+ 0x70000000: 0x800000,+ 0x80000000: 0x202,+ 0x90000000: 0x800200,+ 0xa0000000: 0x8200,+ 0xb0000000: 0x808000,+ 0xc0000000: 0x8002,+ 0xd0000000: 0x800002,+ 0xe0000000: 0x0,+ 0xf0000000: 0x8202,+ 0x8000000: 0x0,+ 0x18000000: 0x808202,+ 0x28000000: 0x8202,+ 0x38000000: 0x8000,+ 0x48000000: 0x808200,+ 0x58000000: 0x200,+ 0x68000000: 0x808002,+ 0x78000000: 0x2,+ 0x88000000: 0x800200,+ 0x98000000: 0x8200,+ 0xa8000000: 0x808000,+ 0xb8000000: 0x800202,+ 0xc8000000: 0x800002,+ 0xd8000000: 0x8002,+ 0xe8000000: 0x202,+ 0xf8000000: 0x800000,+ 0x1: 0x8000,+ 0x10000001: 0x2,+ 0x20000001: 0x808200,+ 0x30000001: 0x800000,+ 0x40000001: 0x808002,+ 0x50000001: 0x8200,+ 0x60000001: 0x200,+ 0x70000001: 0x800202,+ 0x80000001: 0x808202,+ 0x90000001: 0x808000,+ 0xa0000001: 0x800002,+ 0xb0000001: 0x8202,+ 0xc0000001: 0x202,+ 0xd0000001: 0x800200,+ 0xe0000001: 0x8002,+ 0xf0000001: 0x0,+ 0x8000001: 0x808202,+ 0x18000001: 0x808000,+ 0x28000001: 0x800000,+ 0x38000001: 0x200,+ 0x48000001: 0x8000,+ 0x58000001: 0x800002,+ 0x68000001: 0x2,+ 0x78000001: 0x8202,+ 0x88000001: 0x8002,+ 0x98000001: 0x800202,+ 0xa8000001: 0x202,+ 0xb8000001: 0x808200,+ 0xc8000001: 0x800200,+ 0xd8000001: 0x0,+ 0xe8000001: 0x8200,+ 0xf8000001: 0x808002+ },+ {+ 0x0: 0x40084010,+ 0x1000000: 0x4000,+ 0x2000000: 0x80000,+ 0x3000000: 0x40080010,+ 0x4000000: 0x40000010,+ 0x5000000: 0x40084000,+ 0x6000000: 0x40004000,+ 0x7000000: 0x10,+ 0x8000000: 0x84000,+ 0x9000000: 0x40004010,+ 0xa000000: 0x40000000,+ 0xb000000: 0x84010,+ 0xc000000: 0x80010,+ 0xd000000: 0x0,+ 0xe000000: 0x4010,+ 0xf000000: 0x40080000,+ 0x800000: 0x40004000,+ 0x1800000: 0x84010,+ 0x2800000: 0x10,+ 0x3800000: 0x40004010,+ 0x4800000: 0x40084010,+ 0x5800000: 0x40000000,+ 0x6800000: 0x80000,+ 0x7800000: 0x40080010,+ 0x8800000: 0x80010,+ 0x9800000: 0x0,+ 0xa800000: 0x4000,+ 0xb800000: 0x40080000,+ 0xc800000: 0x40000010,+ 0xd800000: 0x84000,+ 0xe800000: 0x40084000,+ 0xf800000: 0x4010,+ 0x10000000: 0x0,+ 0x11000000: 0x40080010,+ 0x12000000: 0x40004010,+ 0x13000000: 0x40084000,+ 0x14000000: 0x40080000,+ 0x15000000: 0x10,+ 0x16000000: 0x84010,+ 0x17000000: 0x4000,+ 0x18000000: 0x4010,+ 0x19000000: 0x80000,+ 0x1a000000: 0x80010,+ 0x1b000000: 0x40000010,+ 0x1c000000: 0x84000,+ 0x1d000000: 0x40004000,+ 0x1e000000: 0x40000000,+ 0x1f000000: 0x40084010,+ 0x10800000: 0x84010,+ 0x11800000: 0x80000,+ 0x12800000: 0x40080000,+ 0x13800000: 0x4000,+ 0x14800000: 0x40004000,+ 0x15800000: 0x40084010,+ 0x16800000: 0x10,+ 0x17800000: 0x40000000,+ 0x18800000: 0x40084000,+ 0x19800000: 0x40000010,+ 0x1a800000: 0x40004010,+ 0x1b800000: 0x80010,+ 0x1c800000: 0x0,+ 0x1d800000: 0x4010,+ 0x1e800000: 0x40080010,+ 0x1f800000: 0x84000+ },+ {+ 0x0: 0x104,+ 0x100000: 0x0,+ 0x200000: 0x4000100,+ 0x300000: 0x10104,+ 0x400000: 0x10004,+ 0x500000: 0x4000004,+ 0x600000: 0x4010104,+ 0x700000: 0x4010000,+ 0x800000: 0x4000000,+ 0x900000: 0x4010100,+ 0xa00000: 0x10100,+ 0xb00000: 0x4010004,+ 0xc00000: 0x4000104,+ 0xd00000: 0x10000,+ 0xe00000: 0x4,+ 0xf00000: 0x100,+ 0x80000: 0x4010100,+ 0x180000: 0x4010004,+ 0x280000: 0x0,+ 0x380000: 0x4000100,+ 0x480000: 0x4000004,+ 0x580000: 0x10000,+ 0x680000: 0x10004,+ 0x780000: 0x104,+ 0x880000: 0x4,+ 0x980000: 0x100,+ 0xa80000: 0x4010000,+ 0xb80000: 0x10104,+ 0xc80000: 0x10100,+ 0xd80000: 0x4000104,+ 0xe80000: 0x4010104,+ 0xf80000: 0x4000000,+ 0x1000000: 0x4010100,+ 0x1100000: 0x10004,+ 0x1200000: 0x10000,+ 0x1300000: 0x4000100,+ 0x1400000: 0x100,+ 0x1500000: 0x4010104,+ 0x1600000: 0x4000004,+ 0x1700000: 0x0,+ 0x1800000: 0x4000104,+ 0x1900000: 0x4000000,+ 0x1a00000: 0x4,+ 0x1b00000: 0x10100,+ 0x1c00000: 0x4010000,+ 0x1d00000: 0x104,+ 0x1e00000: 0x10104,+ 0x1f00000: 0x4010004,+ 0x1080000: 0x4000000,+ 0x1180000: 0x104,+ 0x1280000: 0x4010100,+ 0x1380000: 0x0,+ 0x1480000: 0x10004,+ 0x1580000: 0x4000100,+ 0x1680000: 0x100,+ 0x1780000: 0x4010004,+ 0x1880000: 0x10000,+ 0x1980000: 0x4010104,+ 0x1a80000: 0x10104,+ 0x1b80000: 0x4000004,+ 0x1c80000: 0x4000104,+ 0x1d80000: 0x4010000,+ 0x1e80000: 0x4,+ 0x1f80000: 0x10100+ },+ {+ 0x0: 0x80401000,+ 0x10000: 0x80001040,+ 0x20000: 0x401040,+ 0x30000: 0x80400000,+ 0x40000: 0x0,+ 0x50000: 0x401000,+ 0x60000: 0x80000040,+ 0x70000: 0x400040,+ 0x80000: 0x80000000,+ 0x90000: 0x400000,+ 0xa0000: 0x40,+ 0xb0000: 0x80001000,+ 0xc0000: 0x80400040,+ 0xd0000: 0x1040,+ 0xe0000: 0x1000,+ 0xf0000: 0x80401040,+ 0x8000: 0x80001040,+ 0x18000: 0x40,+ 0x28000: 0x80400040,+ 0x38000: 0x80001000,+ 0x48000: 0x401000,+ 0x58000: 0x80401040,+ 0x68000: 0x0,+ 0x78000: 0x80400000,+ 0x88000: 0x1000,+ 0x98000: 0x80401000,+ 0xa8000: 0x400000,+ 0xb8000: 0x1040,+ 0xc8000: 0x80000000,+ 0xd8000: 0x400040,+ 0xe8000: 0x401040,+ 0xf8000: 0x80000040,+ 0x100000: 0x400040,+ 0x110000: 0x401000,+ 0x120000: 0x80000040,+ 0x130000: 0x0,+ 0x140000: 0x1040,+ 0x150000: 0x80400040,+ 0x160000: 0x80401000,+ 0x170000: 0x80001040,+ 0x180000: 0x80401040,+ 0x190000: 0x80000000,+ 0x1a0000: 0x80400000,+ 0x1b0000: 0x401040,+ 0x1c0000: 0x80001000,+ 0x1d0000: 0x400000,+ 0x1e0000: 0x40,+ 0x1f0000: 0x1000,+ 0x108000: 0x80400000,+ 0x118000: 0x80401040,+ 0x128000: 0x0,+ 0x138000: 0x401000,+ 0x148000: 0x400040,+ 0x158000: 0x80000000,+ 0x168000: 0x80001040,+ 0x178000: 0x40,+ 0x188000: 0x80000040,+ 0x198000: 0x1000,+ 0x1a8000: 0x80001000,+ 0x1b8000: 0x80400040,+ 0x1c8000: 0x1040,+ 0x1d8000: 0x80401000,+ 0x1e8000: 0x400000,+ 0x1f8000: 0x401040+ },+ {+ 0x0: 0x80,+ 0x1000: 0x1040000,+ 0x2000: 0x40000,+ 0x3000: 0x20000000,+ 0x4000: 0x20040080,+ 0x5000: 0x1000080,+ 0x6000: 0x21000080,+ 0x7000: 0x40080,+ 0x8000: 0x1000000,+ 0x9000: 0x20040000,+ 0xa000: 0x20000080,+ 0xb000: 0x21040080,+ 0xc000: 0x21040000,+ 0xd000: 0x0,+ 0xe000: 0x1040080,+ 0xf000: 0x21000000,+ 0x800: 0x1040080,+ 0x1800: 0x21000080,+ 0x2800: 0x80,+ 0x3800: 0x1040000,+ 0x4800: 0x40000,+ 0x5800: 0x20040080,+ 0x6800: 0x21040000,+ 0x7800: 0x20000000,+ 0x8800: 0x20040000,+ 0x9800: 0x0,+ 0xa800: 0x21040080,+ 0xb800: 0x1000080,+ 0xc800: 0x20000080,+ 0xd800: 0x21000000,+ 0xe800: 0x1000000,+ 0xf800: 0x40080,+ 0x10000: 0x40000,+ 0x11000: 0x80,+ 0x12000: 0x20000000,+ 0x13000: 0x21000080,+ 0x14000: 0x1000080,+ 0x15000: 0x21040000,+ 0x16000: 0x20040080,+ 0x17000: 0x1000000,+ 0x18000: 0x21040080,+ 0x19000: 0x21000000,+ 0x1a000: 0x1040000,+ 0x1b000: 0x20040000,+ 0x1c000: 0x40080,+ 0x1d000: 0x20000080,+ 0x1e000: 0x0,+ 0x1f000: 0x1040080,+ 0x10800: 0x21000080,+ 0x11800: 0x1000000,+ 0x12800: 0x1040000,+ 0x13800: 0x20040080,+ 0x14800: 0x20000000,+ 0x15800: 0x1040080,+ 0x16800: 0x80,+ 0x17800: 0x21040000,+ 0x18800: 0x40080,+ 0x19800: 0x21040080,+ 0x1a800: 0x0,+ 0x1b800: 0x21000000,+ 0x1c800: 0x1000080,+ 0x1d800: 0x40000,+ 0x1e800: 0x20040000,+ 0x1f800: 0x20000080+ },+ {+ 0x0: 0x10000008,+ 0x100: 0x2000,+ 0x200: 0x10200000,+ 0x300: 0x10202008,+ 0x400: 0x10002000,+ 0x500: 0x200000,+ 0x600: 0x200008,+ 0x700: 0x10000000,+ 0x800: 0x0,+ 0x900: 0x10002008,+ 0xa00: 0x202000,+ 0xb00: 0x8,+ 0xc00: 0x10200008,+ 0xd00: 0x202008,+ 0xe00: 0x2008,+ 0xf00: 0x10202000,+ 0x80: 0x10200000,+ 0x180: 0x10202008,+ 0x280: 0x8,+ 0x380: 0x200000,+ 0x480: 0x202008,+ 0x580: 0x10000008,+ 0x680: 0x10002000,+ 0x780: 0x2008,+ 0x880: 0x200008,+ 0x980: 0x2000,+ 0xa80: 0x10002008,+ 0xb80: 0x10200008,+ 0xc80: 0x0,+ 0xd80: 0x10202000,+ 0xe80: 0x202000,+ 0xf80: 0x10000000,+ 0x1000: 0x10002000,+ 0x1100: 0x10200008,+ 0x1200: 0x10202008,+ 0x1300: 0x2008,+ 0x1400: 0x200000,+ 0x1500: 0x10000000,+ 0x1600: 0x10000008,+ 0x1700: 0x202000,+ 0x1800: 0x202008,+ 0x1900: 0x0,+ 0x1a00: 0x8,+ 0x1b00: 0x10200000,+ 0x1c00: 0x2000,+ 0x1d00: 0x10002008,+ 0x1e00: 0x10202000,+ 0x1f00: 0x200008,+ 0x1080: 0x8,+ 0x1180: 0x202000,+ 0x1280: 0x200000,+ 0x1380: 0x10000008,+ 0x1480: 0x10002000,+ 0x1580: 0x2008,+ 0x1680: 0x10202008,+ 0x1780: 0x10200000,+ 0x1880: 0x10202000,+ 0x1980: 0x10200008,+ 0x1a80: 0x2000,+ 0x1b80: 0x202008,+ 0x1c80: 0x200008,+ 0x1d80: 0x0,+ 0x1e80: 0x10000000,+ 0x1f80: 0x10002008+ },+ {+ 0x0: 0x100000,+ 0x10: 0x2000401,+ 0x20: 0x400,+ 0x30: 0x100401,+ 0x40: 0x2100401,+ 0x50: 0x0,+ 0x60: 0x1,+ 0x70: 0x2100001,+ 0x80: 0x2000400,+ 0x90: 0x100001,+ 0xa0: 0x2000001,+ 0xb0: 0x2100400,+ 0xc0: 0x2100000,+ 0xd0: 0x401,+ 0xe0: 0x100400,+ 0xf0: 0x2000000,+ 0x8: 0x2100001,+ 0x18: 0x0,+ 0x28: 0x2000401,+ 0x38: 0x2100400,+ 0x48: 0x100000,+ 0x58: 0x2000001,+ 0x68: 0x2000000,+ 0x78: 0x401,+ 0x88: 0x100401,+ 0x98: 0x2000400,+ 0xa8: 0x2100000,+ 0xb8: 0x100001,+ 0xc8: 0x400,+ 0xd8: 0x2100401,+ 0xe8: 0x1,+ 0xf8: 0x100400,+ 0x100: 0x2000000,+ 0x110: 0x100000,+ 0x120: 0x2000401,+ 0x130: 0x2100001,+ 0x140: 0x100001,+ 0x150: 0x2000400,+ 0x160: 0x2100400,+ 0x170: 0x100401,+ 0x180: 0x401,+ 0x190: 0x2100401,+ 0x1a0: 0x100400,+ 0x1b0: 0x1,+ 0x1c0: 0x0,+ 0x1d0: 0x2100000,+ 0x1e0: 0x2000001,+ 0x1f0: 0x400,+ 0x108: 0x100400,+ 0x118: 0x2000401,+ 0x128: 0x2100001,+ 0x138: 0x1,+ 0x148: 0x2000000,+ 0x158: 0x100000,+ 0x168: 0x401,+ 0x178: 0x2100400,+ 0x188: 0x2000001,+ 0x198: 0x2100000,+ 0x1a8: 0x0,+ 0x1b8: 0x2100401,+ 0x1c8: 0x100401,+ 0x1d8: 0x400,+ 0x1e8: 0x2000400,+ 0x1f8: 0x100001+ },+ {+ 0x0: 0x8000820,+ 0x1: 0x20000,+ 0x2: 0x8000000,+ 0x3: 0x20,+ 0x4: 0x20020,+ 0x5: 0x8020820,+ 0x6: 0x8020800,+ 0x7: 0x800,+ 0x8: 0x8020000,+ 0x9: 0x8000800,+ 0xa: 0x20800,+ 0xb: 0x8020020,+ 0xc: 0x820,+ 0xd: 0x0,+ 0xe: 0x8000020,+ 0xf: 0x20820,+ 0x80000000: 0x800,+ 0x80000001: 0x8020820,+ 0x80000002: 0x8000820,+ 0x80000003: 0x8000000,+ 0x80000004: 0x8020000,+ 0x80000005: 0x20800,+ 0x80000006: 0x20820,+ 0x80000007: 0x20,+ 0x80000008: 0x8000020,+ 0x80000009: 0x820,+ 0x8000000a: 0x20020,+ 0x8000000b: 0x8020800,+ 0x8000000c: 0x0,+ 0x8000000d: 0x8020020,+ 0x8000000e: 0x8000800,+ 0x8000000f: 0x20000,+ 0x10: 0x20820,+ 0x11: 0x8020800,+ 0x12: 0x20,+ 0x13: 0x800,+ 0x14: 0x8000800,+ 0x15: 0x8000020,+ 0x16: 0x8020020,+ 0x17: 0x20000,+ 0x18: 0x0,+ 0x19: 0x20020,+ 0x1a: 0x8020000,+ 0x1b: 0x8000820,+ 0x1c: 0x8020820,+ 0x1d: 0x20800,+ 0x1e: 0x820,+ 0x1f: 0x8000000,+ 0x80000010: 0x20000,+ 0x80000011: 0x800,+ 0x80000012: 0x8020020,+ 0x80000013: 0x20820,+ 0x80000014: 0x20,+ 0x80000015: 0x8020000,+ 0x80000016: 0x8000000,+ 0x80000017: 0x8000820,+ 0x80000018: 0x8020820,+ 0x80000019: 0x8000020,+ 0x8000001a: 0x8000800,+ 0x8000001b: 0x0,+ 0x8000001c: 0x20800,+ 0x8000001d: 0x820,+ 0x8000001e: 0x20020,+ 0x8000001f: 0x8020800+ }+ ];++ // Masks that select the SBOX input+ var SBOX_MASK = [+ 0xf8000001, 0x1f800000, 0x01f80000, 0x001f8000,+ 0x0001f800, 0x00001f80, 0x000001f8, 0x8000001f+ ];++ /**+ * DES block cipher algorithm.+ */+ var DES = C_algo.DES = BlockCipher.extend({+ _doReset: function () {+ // Shortcuts+ var key = this._key;+ var keyWords = key.words;++ // Select 56 bits according to PC1+ var keyBits = [];+ for (var i = 0; i < 56; i++) {+ var keyBitPos = PC1[i] - 1;+ keyBits[i] = (keyWords[keyBitPos >>> 5] >>> (31 - keyBitPos % 32)) & 1;+ }++ // Assemble 16 subkeys+ var subKeys = this._subKeys = [];+ for (var nSubKey = 0; nSubKey < 16; nSubKey++) {+ // Create subkey+ var subKey = subKeys[nSubKey] = [];++ // Shortcut+ var bitShift = BIT_SHIFTS[nSubKey];++ // Select 48 bits according to PC2+ for (var i = 0; i < 24; i++) {+ // Select from the left 28 key bits+ subKey[(i / 6) | 0] |= keyBits[((PC2[i] - 1) + bitShift) % 28] << (31 - i % 6);++ // Select from the right 28 key bits+ subKey[4 + ((i / 6) | 0)] |= keyBits[28 + (((PC2[i + 24] - 1) + bitShift) % 28)] << (31 - i % 6);+ }++ // Since each subkey is applied to an expanded 32-bit input,+ // the subkey can be broken into 8 values scaled to 32-bits,+ // which allows the key to be used without expansion+ subKey[0] = (subKey[0] << 1) | (subKey[0] >>> 31);+ for (var i = 1; i < 7; i++) {+ subKey[i] = subKey[i] >>> ((i - 1) * 4 + 3);+ }+ subKey[7] = (subKey[7] << 5) | (subKey[7] >>> 27);+ }++ // Compute inverse subkeys+ var invSubKeys = this._invSubKeys = [];+ for (var i = 0; i < 16; i++) {+ invSubKeys[i] = subKeys[15 - i];+ }+ },++ encryptBlock: function (M, offset) {+ this._doCryptBlock(M, offset, this._subKeys);+ },++ decryptBlock: function (M, offset) {+ this._doCryptBlock(M, offset, this._invSubKeys);+ },++ _doCryptBlock: function (M, offset, subKeys) {+ // Get input+ this._lBlock = M[offset];+ this._rBlock = M[offset + 1];++ // Initial permutation+ exchangeLR.call(this, 4, 0x0f0f0f0f);+ exchangeLR.call(this, 16, 0x0000ffff);+ exchangeRL.call(this, 2, 0x33333333);+ exchangeRL.call(this, 8, 0x00ff00ff);+ exchangeLR.call(this, 1, 0x55555555);++ // Rounds+ for (var round = 0; round < 16; round++) {+ // Shortcuts+ var subKey = subKeys[round];+ var lBlock = this._lBlock;+ var rBlock = this._rBlock;++ // Feistel function+ var f = 0;+ for (var i = 0; i < 8; i++) {+ f |= SBOX_P[i][((rBlock ^ subKey[i]) & SBOX_MASK[i]) >>> 0];+ }+ this._lBlock = rBlock;+ this._rBlock = lBlock ^ f;+ }++ // Undo swap from last round+ var t = this._lBlock;+ this._lBlock = this._rBlock;+ this._rBlock = t;++ // Final permutation+ exchangeLR.call(this, 1, 0x55555555);+ exchangeRL.call(this, 8, 0x00ff00ff);+ exchangeRL.call(this, 2, 0x33333333);+ exchangeLR.call(this, 16, 0x0000ffff);+ exchangeLR.call(this, 4, 0x0f0f0f0f);++ // Set output+ M[offset] = this._lBlock;+ M[offset + 1] = this._rBlock;+ },++ keySize: 64/32,++ ivSize: 64/32,++ blockSize: 64/32+ });++ // Swap bits across the left and right words+ function exchangeLR(offset, mask) {+ var t = ((this._lBlock >>> offset) ^ this._rBlock) & mask;+ this._rBlock ^= t;+ this._lBlock ^= t << offset;+ }++ function exchangeRL(offset, mask) {+ var t = ((this._rBlock >>> offset) ^ this._lBlock) & mask;+ this._lBlock ^= t;+ this._rBlock ^= t << offset;+ }++ /**+ * Shortcut functions to the cipher's object interface.+ *+ * @example+ *+ * var ciphertext = CryptoJS.DES.encrypt(message, key, cfg);+ * var plaintext = CryptoJS.DES.decrypt(ciphertext, key, cfg);+ */+ C.DES = BlockCipher._createHelper(DES);++ /**+ * Triple-DES block cipher algorithm.+ */+ var TripleDES = C_algo.TripleDES = BlockCipher.extend({+ _doReset: function () {+ // Shortcuts+ var key = this._key;+ var keyWords = key.words;++ // Create DES instances+ this._des1 = DES.createEncryptor(WordArray.create(keyWords.slice(0, 2)));+ this._des2 = DES.createEncryptor(WordArray.create(keyWords.slice(2, 4)));+ this._des3 = DES.createEncryptor(WordArray.create(keyWords.slice(4, 6)));+ },++ encryptBlock: function (M, offset) {+ this._des1.encryptBlock(M, offset);+ this._des2.decryptBlock(M, offset);+ this._des3.encryptBlock(M, offset);+ },++ decryptBlock: function (M, offset) {+ this._des3.decryptBlock(M, offset);+ this._des2.encryptBlock(M, offset);+ this._des1.decryptBlock(M, offset);+ },++ keySize: 192/32,++ ivSize: 64/32,++ blockSize: 64/32+ });++ /**+ * Shortcut functions to the cipher's object interface.+ *+ * @example+ *+ * var ciphertext = CryptoJS.TripleDES.encrypt(message, key, cfg);+ * var plaintext = CryptoJS.TripleDES.decrypt(ciphertext, key, cfg);+ */+ C.TripleDES = BlockCipher._createHelper(TripleDES);+ }());+++ return CryptoJS.TripleDES;++}));+},{"./cipher-core":2,"./core":3,"./enc-base64":4,"./evpkdf":6,"./md5":11}],34:[function(require,module,exports){+;(function (root, factory) {+ if (typeof exports === "object") {+ // CommonJS+ module.exports = exports = factory(require("./core"));+ }+ else if (typeof define === "function" && define.amd) {+ // AMD+ define(["./core"], factory);+ }+ else {+ // Global (browser)+ factory(root.CryptoJS);+ }+}(this, function (CryptoJS) {++ (function (undefined) {+ // Shortcuts+ var C = CryptoJS;+ var C_lib = C.lib;+ var Base = C_lib.Base;+ var X32WordArray = C_lib.WordArray;++ /**+ * x64 namespace.+ */+ var C_x64 = C.x64 = {};++ /**+ * A 64-bit word.+ */+ var X64Word = C_x64.Word = Base.extend({+ /**+ * Initializes a newly created 64-bit word.+ *+ * @param {number} high The high 32 bits.+ * @param {number} low The low 32 bits.+ *+ * @example+ *+ * var x64Word = CryptoJS.x64.Word.create(0x00010203, 0x04050607);+ */+ init: function (high, low) {+ this.high = high;+ this.low = low;+ }++ /**+ * Bitwise NOTs this word.+ *+ * @return {X64Word} A new x64-Word object after negating.+ *+ * @example+ *+ * var negated = x64Word.not();+ */+ // not: function () {+ // var high = ~this.high;+ // var low = ~this.low;++ // return X64Word.create(high, low);+ // },++ /**+ * Bitwise ANDs this word with the passed word.+ *+ * @param {X64Word} word The x64-Word to AND with this word.+ *+ * @return {X64Word} A new x64-Word object after ANDing.+ *+ * @example+ *+ * var anded = x64Word.and(anotherX64Word);+ */+ // and: function (word) {+ // var high = this.high & word.high;+ // var low = this.low & word.low;++ // return X64Word.create(high, low);+ // },++ /**+ * Bitwise ORs this word with the passed word.+ *+ * @param {X64Word} word The x64-Word to OR with this word.+ *+ * @return {X64Word} A new x64-Word object after ORing.+ *+ * @example+ *+ * var ored = x64Word.or(anotherX64Word);+ */+ // or: function (word) {+ // var high = this.high | word.high;+ // var low = this.low | word.low;++ // return X64Word.create(high, low);+ // },++ /**+ * Bitwise XORs this word with the passed word.+ *+ * @param {X64Word} word The x64-Word to XOR with this word.+ *+ * @return {X64Word} A new x64-Word object after XORing.+ *+ * @example+ *+ * var xored = x64Word.xor(anotherX64Word);+ */+ // xor: function (word) {+ // var high = this.high ^ word.high;+ // var low = this.low ^ word.low;++ // return X64Word.create(high, low);+ // },++ /**+ * Shifts this word n bits to the left.+ *+ * @param {number} n The number of bits to shift.+ *+ * @return {X64Word} A new x64-Word object after shifting.+ *+ * @example+ *+ * var shifted = x64Word.shiftL(25);+ */+ // shiftL: function (n) {+ // if (n < 32) {+ // var high = (this.high << n) | (this.low >>> (32 - n));+ // var low = this.low << n;+ // } else {+ // var high = this.low << (n - 32);+ // var low = 0;+ // }++ // return X64Word.create(high, low);+ // },++ /**+ * Shifts this word n bits to the right.+ *+ * @param {number} n The number of bits to shift.+ *+ * @return {X64Word} A new x64-Word object after shifting.+ *+ * @example+ *+ * var shifted = x64Word.shiftR(7);+ */+ // shiftR: function (n) {+ // if (n < 32) {+ // var low = (this.low >>> n) | (this.high << (32 - n));+ // var high = this.high >>> n;+ // } else {+ // var low = this.high >>> (n - 32);+ // var high = 0;+ // }++ // return X64Word.create(high, low);+ // },++ /**+ * Rotates this word n bits to the left.+ *+ * @param {number} n The number of bits to rotate.+ *+ * @return {X64Word} A new x64-Word object after rotating.+ *+ * @example+ *+ * var rotated = x64Word.rotL(25);+ */+ // rotL: function (n) {+ // return this.shiftL(n).or(this.shiftR(64 - n));+ // },++ /**+ * Rotates this word n bits to the right.+ *+ * @param {number} n The number of bits to rotate.+ *+ * @return {X64Word} A new x64-Word object after rotating.+ *+ * @example+ *+ * var rotated = x64Word.rotR(7);+ */+ // rotR: function (n) {+ // return this.shiftR(n).or(this.shiftL(64 - n));+ // },++ /**+ * Adds this word with the passed word.+ *+ * @param {X64Word} word The x64-Word to add with this word.+ *+ * @return {X64Word} A new x64-Word object after adding.+ *+ * @example+ *+ * var added = x64Word.add(anotherX64Word);+ */+ // add: function (word) {+ // var low = (this.low + word.low) | 0;+ // var carry = (low >>> 0) < (this.low >>> 0) ? 1 : 0;+ // var high = (this.high + word.high + carry) | 0;++ // return X64Word.create(high, low);+ // }+ });++ /**+ * An array of 64-bit words.+ *+ * @property {Array} words The array of CryptoJS.x64.Word objects.+ * @property {number} sigBytes The number of significant bytes in this word array.+ */+ var X64WordArray = C_x64.WordArray = Base.extend({+ /**+ * Initializes a newly created word array.+ *+ * @param {Array} words (Optional) An array of CryptoJS.x64.Word objects.+ * @param {number} sigBytes (Optional) The number of significant bytes in the words.+ *+ * @example+ *+ * var wordArray = CryptoJS.x64.WordArray.create();+ *+ * var wordArray = CryptoJS.x64.WordArray.create([+ * CryptoJS.x64.Word.create(0x00010203, 0x04050607),+ * CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f)+ * ]);+ *+ * var wordArray = CryptoJS.x64.WordArray.create([+ * CryptoJS.x64.Word.create(0x00010203, 0x04050607),+ * CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f)+ * ], 10);+ */+ init: function (words, sigBytes) {+ words = this.words = words || [];++ if (sigBytes != undefined) {+ this.sigBytes = sigBytes;+ } else {+ this.sigBytes = words.length * 8;+ }+ },++ /**+ * Converts this 64-bit word array to a 32-bit word array.+ *+ * @return {CryptoJS.lib.WordArray} This word array's data as a 32-bit word array.+ *+ * @example+ *+ * var x32WordArray = x64WordArray.toX32();+ */+ toX32: function () {+ // Shortcuts+ var x64Words = this.words;+ var x64WordsLength = x64Words.length;++ // Convert+ var x32Words = [];+ for (var i = 0; i < x64WordsLength; i++) {+ var x64Word = x64Words[i];+ x32Words.push(x64Word.high);+ x32Words.push(x64Word.low);+ }++ return X32WordArray.create(x32Words, this.sigBytes);+ },++ /**+ * Creates a copy of this word array.+ *+ * @return {X64WordArray} The clone.+ *+ * @example+ *+ * var clone = x64WordArray.clone();+ */+ clone: function () {+ var clone = Base.clone.call(this);++ // Clone "words" array+ var words = clone.words = this.words.slice(0);++ // Clone each X64Word object+ var wordsLength = words.length;+ for (var i = 0; i < wordsLength; i++) {+ words[i] = words[i].clone();+ }++ return clone;+ }+ });+ }());+++ return CryptoJS;++}));+},{"./core":3}],35:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Common = require("../Common");+var Control_Applicative = require("../Control.Applicative");+var Control_Bind = require("../Control.Bind");+var Control_Monad_Aff = require("../Control.Monad.Aff");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var Control_Monad_Eff_Console = require("../Control.Monad.Eff.Console");+var Control_Monad_Eff_Exception = require("../Control.Monad.Eff.Exception");+var Control_Monad_Eff_JQuery = require("../Control.Monad.Eff.JQuery");+var DOM = require("../DOM");+var Data_Eq = require("../Data.Eq");+var Data_FormURLEncoded = require("../Data.FormURLEncoded");+var Data_Function = require("../Data.Function");+var Data_Function_Uncurried = require("../Data.Function.Uncurried");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Maybe = require("../Data.Maybe");+var Data_Show = require("../Data.Show");+var Data_Tuple = require("../Data.Tuple");+var Data_Unit = require("../Data.Unit");+var Network_HTTP_Affjax = require("../Network.HTTP.Affjax");+var Network_HTTP_Affjax_Request = require("../Network.HTTP.Affjax.Request");+var Network_HTTP_Affjax_Response = require("../Network.HTTP.Affjax.Response");+var Partial_Unsafe = require("../Partial.Unsafe");+var Prelude = require("../Prelude");+var onActivateClick = function (activate) {+ return function (ev) {+ return function (v) {+ return function __do() {+ Control_Monad_Eff_JQuery.preventDefault(ev)();+ var v1 = Common.getAttr("data-token")(activate)();+ var v2 = Common.getAttr("data-salt")(activate)();+ var v3 = Control_Bind.bindFlipped(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.getValue)(Control_Monad_Eff_JQuery.select("#password1"))();+ var v4 = Control_Bind.bindFlipped(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.getValue)(Control_Monad_Eff_JQuery.select("#password2"))();+ var v5 = Control_Bind.bindFlipped(Control_Monad_Eff.bindEff)(Common.getAttr("action"))(Control_Monad_Eff_JQuery.select("#activateform"))();+ Control_Monad_Eff_Console.log(v5)();+ var password2 = Common.fromForeign(v4);+ var password1 = Common.fromForeign(v3);+ var $13 = !(Data_Maybe.isNothing(password1) && Data_Maybe.isNothing(password2));+ if ($13) {+ var $14 = Data_Eq.eq(Data_Maybe.eqMaybe(Data_Eq.eqString))(password1)(password2);+ if ($14) {+ Common.progress("Salting password")();+ var salted = Common.hmacSha3(Common.fromUtf8(Data_Maybe.fromJust()(password1)), Common.fromHex(v2));+ Common.progress("Requesting account activation...")();+ var dat = Data_FormURLEncoded.fromArray([ new Data_Tuple.Tuple("salted", new Data_Maybe.Just(salted)) ]);+ var v6 = Control_Monad_Aff.runAff(function (e) {+ return Common.fail(Common.Activate.value)(Data_Show.show(Control_Monad_Eff_Exception.showError)(e));+ })(function (x) {+ return Common.welcome(x.response)(Common.Activate.value);+ })(Network_HTTP_Affjax.post(Network_HTTP_Affjax_Request.requestableFormURLEncoded)(Network_HTTP_Affjax_Response.responsableJson)(v5)(dat))();+ return Data_Unit.unit;+ };+ return Common.fail(Common.Activate.value)("Passwords must match")();+ };+ return Common.fail(Common.Activate.value)("Passwords error")();+ };+ };+ };+};+module.exports = {+ onActivateClick: onActivateClick+};++},{"../Common":37,"../Control.Applicative":40,"../Control.Bind":46,"../Control.Monad.Aff":55,"../Control.Monad.Eff":70,"../Control.Monad.Eff.Console":60,"../Control.Monad.Eff.Exception":62,"../Control.Monad.Eff.JQuery":64,"../DOM":100,"../Data.Eq":138,"../Data.FormURLEncoded":146,"../Data.Function":149,"../Data.Function.Uncurried":148,"../Data.HeytingAlgebra":160,"../Data.Maybe":198,"../Data.Show":233,"../Data.Tuple":245,"../Data.Unit":249,"../Network.HTTP.Affjax":260,"../Network.HTTP.Affjax.Request":257,"../Network.HTTP.Affjax.Response":258,"../Partial.Unsafe":265,"../Prelude":268}],36:[function(require,module,exports){+"use strict";++var CryptoJS = require('crypto-js');++exports.hmacSha3 = function(msg, key) {+ var hmac = CryptoJS.HmacSHA3(msg, key);+ //console.log("bla");+ //console.log(hmac.toString());+ //console.log(CryptoJS.enc.Utf8.stringify(hmac));+ return hmac.toString();+}++exports.setLocation = function(newLoc) {+ window.location = newLoc;+ return null;+}++exports.getAttr = function(attr) {+ return function(ob) {+ return function() {+ return ob.attr(attr);+ };+ };+};++exports.toHex = function(str) {+ var repr = parseInt(str, 16);+ return repr.toString(16);+}++exports.fromHex = function(str) {+ return CryptoJS.enc.Hex.parse(str);+}++exports.fromUtf8 = function(str) {+ return CryptoJS.enc.Utf8.parse(str);+}++},{"crypto-js":9}],37:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Applicative = require("../Control.Applicative");+var Control_Bind = require("../Control.Bind");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var Control_Monad_Eff_JQuery = require("../Control.Monad.Eff.JQuery");+var Control_Monad_Except = require("../Control.Monad.Except");+var DOM = require("../DOM");+var Data_Argonaut = require("../Data.Argonaut");+var Data_Argonaut_Decode = require("../Data.Argonaut.Decode");+var Data_Argonaut_Decode_Class = require("../Data.Argonaut.Decode.Class");+var Data_Argonaut_Decode_Combinators = require("../Data.Argonaut.Decode.Combinators");+var Data_Either = require("../Data.Either");+var Data_Foreign = require("../Data.Foreign");+var Data_Function = require("../Data.Function");+var Data_Function_Uncurried = require("../Data.Function.Uncurried");+var Data_Functor = require("../Data.Functor");+var Data_Maybe = require("../Data.Maybe");+var Prelude = require("../Prelude");+var Welcome = (function () {+ function Welcome(value0) {+ this.value0 = value0;+ };+ Welcome.create = function (value0) {+ return new Welcome(value0);+ };+ return Welcome;+})();+var Err = (function () {+ function Err(value0) {+ this.value0 = value0;+ };+ Err.create = function (value0) {+ return new Err(value0);+ };+ return Err;+})();+var Login = (function () {+ function Login() {++ };+ Login.value = new Login();+ return Login;+})();+var Activate = (function () {+ function Activate() {++ };+ Activate.value = new Activate();+ return Activate;+})();+var Challenge = (function () {+ function Challenge(value0) {+ this.value0 = value0;+ };+ Challenge.create = function (value0) {+ return new Challenge(value0);+ };+ return Challenge;+})();+var progress = function (s) {+ return Control_Bind.bindFlipped(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.setText(s))(Control_Monad_Eff_JQuery.select("#progress"));+};+var fromForeign = function (f) {+ var v = Control_Monad_Except.runExcept(Data_Foreign.readString(f));+ if (v instanceof Data_Either.Left) {+ return Data_Maybe.Nothing.value;+ };+ if (v instanceof Data_Either.Right) {+ return new Data_Maybe.Just(v.value0);+ };+ throw new Error("Failed pattern match at Common line 77, column 17 - line 79, column 20: " + [ v.constructor.name ]);+};+var fail = function (v) {+ return function (s) {+ if (v instanceof Login) {+ return function __do() {+ progress(s)();+ var v1 = Data_Functor.map(Control_Monad_Eff.functorEff)(Control_Monad_Eff_JQuery.setProp("disabled")(false))(Control_Monad_Eff_JQuery.select(".login input"))();+ return Control_Bind.bindFlipped(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.display)(Control_Monad_Eff_JQuery.select("#login"))();+ };+ };+ if (v instanceof Activate) {+ return function __do() {+ progress(s)();+ var v1 = Data_Functor.map(Control_Monad_Eff.functorEff)(Control_Monad_Eff_JQuery.setProp("disabled")(false))(Control_Monad_Eff_JQuery.select(".activate input"))();+ return Control_Bind.bindFlipped(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.display)(Control_Monad_Eff_JQuery.select("#activate"))();+ };+ };+ throw new Error("Failed pattern match at Common line 35, column 1 - line 39, column 1: " + [ v.constructor.name, s.constructor.name ]);+ };+};+var decodeJsonWelcome = new Data_Argonaut_Decode_Class.DecodeJson(function (j) {+ return Control_Bind.bind(Data_Either.bindEither)(Data_Argonaut_Decode_Class.decodeJson(Data_Argonaut_Decode_Class.decodeStrMap(Data_Argonaut_Decode_Class.decodeJsonJson))(j))(function (v) {+ return Control_Bind.bind(Data_Either.bindEither)(Data_Argonaut_Decode_Combinators.getField(Data_Argonaut_Decode_Class.decodeJsonString)(v)("welcome"))(function (v1) {+ return Control_Applicative.pure(Data_Either.applicativeEither)(new Welcome({+ link: v1+ }));+ });+ });+});+var decodeJsonErr = new Data_Argonaut_Decode_Class.DecodeJson(function (j) {+ return Control_Bind.bind(Data_Either.bindEither)(Data_Argonaut_Decode_Class.decodeJson(Data_Argonaut_Decode_Class.decodeStrMap(Data_Argonaut_Decode_Class.decodeJsonJson))(j))(function (v) {+ return Control_Bind.bind(Data_Either.bindEither)(Data_Argonaut_Decode_Combinators.getField(Data_Argonaut_Decode_Class.decodeJsonString)(v)("error"))(function (v1) {+ return Control_Applicative.pure(Data_Either.applicativeEither)(new Err({+ err: v1+ }));+ });+ });+});+var welcome = function (j) {+ return function (elem) {+ var eitherWelcome = Data_Argonaut_Decode_Class.decodeJson(decodeJsonWelcome)(j);+ if (eitherWelcome instanceof Data_Either.Left) {+ var eitherErr = Data_Argonaut_Decode_Class.decodeJson(decodeJsonErr)(j);+ return Data_Either.either(fail(elem))(function (v) {+ return fail(elem)(v.value0.err);+ })(eitherErr);+ };+ if (eitherWelcome instanceof Data_Either.Right) {+ return function __do() {+ progress("Welcome!")();+ return $foreign.setLocation(eitherWelcome.value0.value0.link)();+ };+ };+ throw new Error("Failed pattern match at Common line 22, column 3 - line 28, column 28: " + [ eitherWelcome.constructor.name ]);+ };+};+var decodeJsonChallenge = new Data_Argonaut_Decode_Class.DecodeJson(function (j) {+ return Control_Bind.bind(Data_Either.bindEither)(Data_Argonaut_Decode_Class.decodeJson(Data_Argonaut_Decode_Class.decodeStrMap(Data_Argonaut_Decode_Class.decodeJsonJson))(j))(function (v) {+ return Control_Bind.bind(Data_Either.bindEither)(Data_Argonaut_Decode_Combinators.getField(Data_Argonaut_Decode_Class.decodeJsonString)(v)("salt"))(function (v1) {+ return Control_Bind.bind(Data_Either.bindEither)(Data_Argonaut_Decode_Combinators.getField(Data_Argonaut_Decode_Class.decodeJsonString)(v)("token"))(function (v2) {+ return Control_Applicative.pure(Data_Either.applicativeEither)(new Challenge({+ salt: v1, + token: v2+ }));+ });+ });+ });+});+module.exports = {+ Challenge: Challenge, + Login: Login, + Activate: Activate, + Err: Err, + Welcome: Welcome, + fail: fail, + fromForeign: fromForeign, + progress: progress, + welcome: welcome, + decodeJsonChallenge: decodeJsonChallenge, + decodeJsonWelcome: decodeJsonWelcome, + decodeJsonErr: decodeJsonErr, + fromHex: $foreign.fromHex, + fromUtf8: $foreign.fromUtf8, + getAttr: $foreign.getAttr, + hmacSha3: $foreign.hmacSha3, + setLocation: $foreign.setLocation, + toHex: $foreign.toHex+};++},{"../Control.Applicative":40,"../Control.Bind":46,"../Control.Monad.Eff":70,"../Control.Monad.Eff.JQuery":64,"../Control.Monad.Except":73,"../DOM":100,"../Data.Argonaut":114,"../Data.Argonaut.Decode":105,"../Data.Argonaut.Decode.Class":103,"../Data.Argonaut.Decode.Combinators":104,"../Data.Either":136,"../Data.Foreign":145,"../Data.Function":149,"../Data.Function.Uncurried":148,"../Data.Functor":155,"../Data.Maybe":198,"../Prelude":268,"./foreign":36}],38:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Functor = require("../Data.Functor");+var Data_Semigroup = require("../Data.Semigroup");+var Alt = function (Functor0, alt) {+ this.Functor0 = Functor0;+ this.alt = alt;+};+var altArray = new Alt(function () {+ return Data_Functor.functorArray;+}, Data_Semigroup.append(Data_Semigroup.semigroupArray));+var alt = function (dict) {+ return dict.alt;+};+module.exports = {+ Alt: Alt, + alt: alt, + altArray: altArray+};++},{"../Data.Functor":155,"../Data.Semigroup":229}],39:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Plus = require("../Control.Plus");+var Data_Functor = require("../Data.Functor");+var Alternative = function (Applicative0, Plus1) {+ this.Applicative0 = Applicative0;+ this.Plus1 = Plus1;+};+var alternativeArray = new Alternative(function () {+ return Control_Applicative.applicativeArray;+}, function () {+ return Control_Plus.plusArray;+});+module.exports = {+ Alternative: Alternative, + alternativeArray: alternativeArray+};++},{"../Control.Alt":38,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Plus":91,"../Data.Functor":155}],40:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Apply = require("../Control.Apply");+var Data_Functor = require("../Data.Functor");+var Data_Unit = require("../Data.Unit");+var Applicative = function (Apply0, pure) {+ this.Apply0 = Apply0;+ this.pure = pure;+};+var pure = function (dict) {+ return dict.pure;+};+var unless = function (dictApplicative) {+ return function (v) {+ return function (v1) {+ if (!v) {+ return v1;+ };+ if (v) {+ return pure(dictApplicative)(Data_Unit.unit);+ };+ throw new Error("Failed pattern match at Control.Applicative line 63, column 1 - line 63, column 19: " + [ v.constructor.name, v1.constructor.name ]);+ };+ };+};+var when = function (dictApplicative) {+ return function (v) {+ return function (v1) {+ if (v) {+ return v1;+ };+ if (!v) {+ return pure(dictApplicative)(Data_Unit.unit);+ };+ throw new Error("Failed pattern match at Control.Applicative line 58, column 1 - line 58, column 16: " + [ v.constructor.name, v1.constructor.name ]);+ };+ };+};+var liftA1 = function (dictApplicative) {+ return function (f) {+ return function (a) {+ return Control_Apply.apply(dictApplicative.Apply0())(pure(dictApplicative)(f))(a);+ };+ };+};+var applicativeFn = new Applicative(function () {+ return Control_Apply.applyFn;+}, function (x) {+ return function (v) {+ return x;+ };+});+var applicativeArray = new Applicative(function () {+ return Control_Apply.applyArray;+}, function (x) {+ return [ x ];+});+module.exports = {+ Applicative: Applicative, + liftA1: liftA1, + pure: pure, + unless: unless, + when: when, + applicativeFn: applicativeFn, + applicativeArray: applicativeArray+};++},{"../Control.Apply":42,"../Data.Functor":155,"../Data.Unit":249}],41:[function(require,module,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;+ };+};++},{}],42:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Category = require("../Control.Category");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Apply = function (Functor0, apply) {+ this.Functor0 = Functor0;+ this.apply = apply;+};+var applyFn = new Apply(function () {+ return Data_Functor.functorFn;+}, function (f) {+ return function (g) {+ return function (x) {+ return f(x)(g(x));+ };+ };+});+var applyArray = new Apply(function () {+ return Data_Functor.functorArray;+}, $foreign.arrayApply);+var apply = function (dict) {+ return dict.apply;+};+var applyFirst = function (dictApply) {+ return function (a) {+ return function (b) {+ return apply(dictApply)(Data_Functor.map(dictApply.Functor0())(Data_Function["const"])(a))(b);+ };+ };+};+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);+ };+ };+};+var lift2 = function (dictApply) {+ return function (f) {+ return function (a) {+ return function (b) {+ return apply(dictApply)(Data_Functor.map(dictApply.Functor0())(f)(a))(b);+ };+ };+ };+};+var lift3 = function (dictApply) {+ return function (f) {+ return function (a) {+ return function (b) {+ return function (c) {+ return apply(dictApply)(apply(dictApply)(Data_Functor.map(dictApply.Functor0())(f)(a))(b))(c);+ };+ };+ };+ };+};+var lift4 = function (dictApply) {+ return function (f) {+ return function (a) {+ return function (b) {+ return function (c) {+ return function (d) {+ return apply(dictApply)(apply(dictApply)(apply(dictApply)(Data_Functor.map(dictApply.Functor0())(f)(a))(b))(c))(d);+ };+ };+ };+ };+ };+};+var lift5 = function (dictApply) {+ return function (f) {+ return function (a) {+ return function (b) {+ return function (c) {+ return function (d) {+ return function (e) {+ return apply(dictApply)(apply(dictApply)(apply(dictApply)(apply(dictApply)(Data_Functor.map(dictApply.Functor0())(f)(a))(b))(c))(d))(e);+ };+ };+ };+ };+ };+ };+};+module.exports = {+ Apply: Apply, + apply: apply, + applyFirst: applyFirst, + applySecond: applySecond, + lift2: lift2, + lift3: lift3, + lift4: lift4, + lift5: lift5, + applyFn: applyFn, + applyArray: applyArray+};++},{"../Control.Category":47,"../Data.Function":149,"../Data.Functor":155,"./foreign":41}],43:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Biapply = require("../Control.Biapply");+var Biapplicative = function (Biapply0, bipure) {+ this.Biapply0 = Biapply0;+ this.bipure = bipure;+};+var bipure = function (dict) {+ return dict.bipure;+};+module.exports = {+ Biapplicative: Biapplicative, + bipure: bipure+};++},{"../Control.Biapply":44}],44:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var Data_Bifunctor = require("../Data.Bifunctor");+var Data_Function = require("../Data.Function");+var Biapply = function (Bifunctor0, biapply) {+ this.Bifunctor0 = Bifunctor0;+ this.biapply = biapply;+};+var biapply = function (dict) {+ return dict.biapply;+};+var biapplyFirst = function (dictBiapply) {+ return function (a) {+ return function (b) {+ return biapply(dictBiapply)(Control_Category.id(Control_Category.categoryFn)(Data_Bifunctor.bimap(dictBiapply.Bifunctor0())(Data_Function["const"](Control_Category.id(Control_Category.categoryFn)))(Data_Function["const"](Control_Category.id(Control_Category.categoryFn))))(a))(b);+ };+ };+};+var biapplySecond = function (dictBiapply) {+ return function (a) {+ return function (b) {+ return biapply(dictBiapply)(Control_Category.id(Control_Category.categoryFn)(Data_Bifunctor.bimap(dictBiapply.Bifunctor0())(Data_Function["const"])(Data_Function["const"]))(a))(b);+ };+ };+};+var bilift2 = function (dictBiapply) {+ return function (f) {+ return function (g) {+ return function (a) {+ return function (b) {+ return biapply(dictBiapply)(Control_Category.id(Control_Category.categoryFn)(Data_Bifunctor.bimap(dictBiapply.Bifunctor0())(f)(g))(a))(b);+ };+ };+ };+ };+};+var bilift3 = function (dictBiapply) {+ return function (f) {+ return function (g) {+ return function (a) {+ return function (b) {+ return function (c) {+ return biapply(dictBiapply)(biapply(dictBiapply)(Control_Category.id(Control_Category.categoryFn)(Data_Bifunctor.bimap(dictBiapply.Bifunctor0())(f)(g))(a))(b))(c);+ };+ };+ };+ };+ };+};+module.exports = {+ Biapply: Biapply, + biapply: biapply, + biapplyFirst: biapplyFirst, + biapplySecond: biapplySecond, + bilift2: bilift2, + bilift3: bilift3+};++},{"../Control.Category":47,"../Data.Bifunctor":127,"../Data.Function":149}],45:[function(require,module,exports){+"use strict";++exports.arrayBind = function (arr) {+ return function (f) {+ var result = [];+ for (var i = 0, l = arr.length; i < l; i++) {+ Array.prototype.push.apply(result, f(arr[i]));+ }+ return result;+ };+};++},{}],46:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Category = require("../Control.Category");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Unit = require("../Data.Unit");+var Bind = function (Apply0, bind) {+ this.Apply0 = Apply0;+ this.bind = bind;+};+var Discard = function (discard) {+ this.discard = discard;+};+var discard = function (dict) {+ return dict.discard;+};+var bindFn = new Bind(function () {+ return Control_Apply.applyFn;+}, function (m) {+ return function (f) {+ return function (x) {+ return f(m(x))(x);+ };+ };+});+var bindArray = new Bind(function () {+ return Control_Apply.applyArray;+}, $foreign.arrayBind);+var bind = function (dict) {+ return dict.bind;+};+var bindFlipped = function (dictBind) {+ return Data_Function.flip(bind(dictBind));+};+var composeKleisliFlipped = function (dictBind) {+ return function (f) {+ return function (g) {+ return function (a) {+ return bindFlipped(dictBind)(f)(g(a));+ };+ };+ };+};+var composeKleisli = function (dictBind) {+ return function (f) {+ return function (g) {+ return function (a) {+ return bind(dictBind)(f(a))(g);+ };+ };+ };+};+var discardUnit = new Discard(function (dictBind) {+ return bind(dictBind);+});+var ifM = function (dictBind) {+ return function (cond) {+ return function (t) {+ return function (f) {+ return bind(dictBind)(cond)(function (cond$prime) {+ if (cond$prime) {+ return t;+ };+ return f;+ });+ };+ };+ };+};+var join = function (dictBind) {+ return function (m) {+ return bind(dictBind)(m)(Control_Category.id(Control_Category.categoryFn));+ };+};+module.exports = {+ Bind: Bind, + Discard: Discard, + bind: bind, + bindFlipped: bindFlipped, + composeKleisli: composeKleisli, + composeKleisliFlipped: composeKleisliFlipped, + discard: discard, + ifM: ifM, + join: join, + bindFn: bindFn, + bindArray: bindArray, + discardUnit: discardUnit+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Category":47,"../Data.Function":149,"../Data.Functor":155,"../Data.Unit":249,"./foreign":45}],47:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Category = function (Semigroupoid0, id) {+ this.Semigroupoid0 = Semigroupoid0;+ this.id = id;+};+var id = function (dict) {+ return dict.id;+};+var categoryFn = new Category(function () {+ return Control_Semigroupoid.semigroupoidFn;+}, function (x) {+ return x;+});+module.exports = {+ Category: Category, + id: id, + categoryFn: categoryFn+};++},{"../Control.Semigroupoid":92}],48:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Extend = require("../Control.Extend");+var Data_Functor = require("../Data.Functor");+var Comonad = function (Extend0, extract) {+ this.Extend0 = Extend0;+ this.extract = extract;+};+var extract = function (dict) {+ return dict.extract;+};+module.exports = {+ Comonad: Comonad, + extract: extract+};++},{"../Control.Extend":49,"../Data.Functor":155}],49:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var Data_Functor = require("../Data.Functor");+var Data_Semigroup = require("../Data.Semigroup");+var Extend = function (Functor0, extend) {+ this.Functor0 = Functor0;+ this.extend = extend;+};+var extendFn = function (dictSemigroup) {+ return new Extend(function () {+ return Data_Functor.functorFn;+ }, function (f) {+ return function (g) {+ return function (w) {+ return f(function (w$prime) {+ return g(Data_Semigroup.append(dictSemigroup)(w)(w$prime));+ });+ };+ };+ });+};+var extend = function (dict) {+ return dict.extend;+};+var extendFlipped = function (dictExtend) {+ return function (w) {+ return function (f) {+ return extend(dictExtend)(f)(w);+ };+ };+};+var duplicate = function (dictExtend) {+ return extend(dictExtend)(Control_Category.id(Control_Category.categoryFn));+};+var composeCoKleisliFlipped = function (dictExtend) {+ return function (f) {+ return function (g) {+ return function (w) {+ return f(extend(dictExtend)(g)(w));+ };+ };+ };+};+var composeCoKleisli = function (dictExtend) {+ return function (f) {+ return function (g) {+ return function (w) {+ return g(extend(dictExtend)(f)(w));+ };+ };+ };+};+module.exports = {+ Extend: Extend, + composeCoKleisli: composeCoKleisli, + composeCoKleisliFlipped: composeCoKleisliFlipped, + duplicate: duplicate, + extend: extend, + extendFlipped: extendFlipped, + extendFn: extendFn+};++},{"../Control.Category":47,"../Data.Functor":155,"../Data.Semigroup":229}],50:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Unit = require("../Data.Unit");+var Lazy = function (defer) {+ this.defer = defer;+};+var defer = function (dict) {+ return dict.defer;+};+var fix = function (dictLazy) {+ return function (f) {+ return defer(dictLazy)(function (v) {+ return f(fix(dictLazy)(f));+ });+ };+};+module.exports = {+ Lazy: Lazy, + defer: defer, + fix: fix+};++},{"../Data.Unit":249}],51:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Bind = require("../Control.Bind");+var Control_Monad_Aff = require("../Control.Monad.Aff");+var Control_Monad_Aff_Internal = require("../Control.Monad.Aff.Internal");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var Control_Monad_Eff_Exception = require("../Control.Monad.Eff.Exception");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Function = require("../Data.Function");+var Data_Function_Uncurried = require("../Data.Function.Uncurried");+var Prelude = require("../Prelude");+var Unsafe_Coerce = require("../Unsafe.Coerce");+var fromAVBox = Unsafe_Coerce.unsafeCoerce;+var killVar = function (q) {+ return function (e) {+ return fromAVBox(Control_Monad_Aff_Internal._killVar(Control_Monad_Aff.nonCanceler, q, e));+ };+};+var makeVar = fromAVBox(Control_Monad_Aff_Internal._makeVar(Control_Monad_Aff.nonCanceler));+var peekVar = function (q) {+ return fromAVBox(Control_Monad_Aff_Internal._peekVar(Control_Monad_Aff.nonCanceler, q));+};+var putVar = function (q) {+ return function (a) {+ return fromAVBox(Control_Monad_Aff_Internal._putVar(Control_Monad_Aff.nonCanceler, q, a));+ };+};+var makeVar$prime = function (a) {+ return Control_Bind.bind(Control_Monad_Aff.bindAff)(makeVar)(function (v) {+ return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Aff.bindAff)(putVar(v)(a))(function () {+ return Control_Applicative.pure(Control_Monad_Aff.applicativeAff)(v);+ });+ });+};+var takeVar = function (q) {+ return fromAVBox(Control_Monad_Aff_Internal._takeVar(Control_Monad_Aff.nonCanceler, q));+};+var modifyVar = function (f) {+ return function (v) {+ return Control_Bind.bind(Control_Monad_Aff.bindAff)(takeVar(v))(function ($2) {+ return putVar(v)(f($2));+ });+ };+};+module.exports = {+ killVar: killVar, + makeVar: makeVar, + "makeVar'": makeVar$prime, + modifyVar: modifyVar, + peekVar: peekVar, + putVar: putVar, + takeVar: takeVar+};++},{"../Control.Applicative":40,"../Control.Bind":46,"../Control.Monad.Aff":55,"../Control.Monad.Aff.Internal":53,"../Control.Monad.Eff":70,"../Control.Monad.Eff.Exception":62,"../Control.Semigroupoid":92,"../Data.Function":149,"../Data.Function.Uncurried":148,"../Prelude":268,"../Unsafe.Coerce":271}],52:[function(require,module,exports){+"use strict";++exports._makeVar = function (nonCanceler) {+ return function (success) {+ success({+ consumers: [],+ producers: [],+ error: undefined+ });+ return nonCanceler;+ };+};++exports._takeVar = function (nonCanceler, avar) {+ return function (success, error) {+ if (avar.error !== undefined) {+ error(avar.error);+ } else if (avar.producers.length > 0) {+ avar.producers.shift()(success, error);+ } else {+ avar.consumers.push({ peek: false, success: success, error: error });+ }++ return nonCanceler;+ };+};++exports._peekVar = function (nonCanceler, avar) {+ return function (success, error) {+ if (avar.error !== undefined) {+ error(avar.error);+ } else if (avar.producers.length > 0) {+ avar.producers[0](success, error);+ } else {+ avar.consumers.push({ peek: true, success: success, error: error });+ }+ return nonCanceler;+ };+};++exports._putVar = function (nonCanceler, avar, a) {+ return function (success, error) {+ if (avar.error !== undefined) {+ error(avar.error);+ } else {+ var shouldQueue = true;+ var consumers = [];+ var consumer;++ while (true) {+ consumer = avar.consumers.shift();+ if (consumer) {+ consumers.push(consumer);+ if (consumer.peek) {+ continue;+ } else {+ shouldQueue = false;+ }+ }+ break;+ }++ if (shouldQueue) {+ avar.producers.push(function (success) {+ success(a);+ return nonCanceler;+ });+ }++ for (var i = 0; i < consumers.length; i++) {+ consumers[i].success(a);+ }++ success({});+ }++ return nonCanceler;+ };+};++exports._killVar = function (nonCanceler, avar, e) {+ return function (success, error) {+ if (avar.error !== undefined) {+ error(avar.error);+ } else {+ avar.error = e;+ while (avar.consumers.length) {+ avar.consumers.shift().error(e);+ }+ success({});+ }++ return nonCanceler;+ };+};++},{}],53:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Monad_Eff_Exception = require("../Control.Monad.Eff.Exception");+var Data_Function_Uncurried = require("../Data.Function.Uncurried");+var Prelude = require("../Prelude");+module.exports = {+ _killVar: $foreign._killVar, + _makeVar: $foreign._makeVar, + _peekVar: $foreign._peekVar, + _putVar: $foreign._putVar, + _takeVar: $foreign._takeVar+};++},{"../Control.Monad.Eff.Exception":62,"../Data.Function.Uncurried":148,"../Prelude":268,"./foreign":52}],54:[function(require,module,exports){+/* globals setTimeout, clearTimeout, setImmediate, clearImmediate */+"use strict";++exports._cancelWith = function (nonCanceler, aff, canceler1) {+ return function (success, error) {+ var canceler2 = aff(success, error);++ return function (e) {+ return function (success, error) {+ var cancellations = 0;+ var result = false;+ var errored = false;++ var s = function (bool) {+ cancellations = cancellations + 1;+ result = result || bool;++ if (cancellations === 2 && !errored) {+ success(result);+ }+ };++ var f = function (err) {+ if (!errored) {+ errored = true;+ error(err);+ }+ };++ canceler2(e)(s, f);+ canceler1(e)(s, f);++ return nonCanceler;+ };+ };+ };+};++exports._delay = function (nonCanceler, millis) {+ var set = setTimeout;+ var clear = clearTimeout;+ if (millis <= 0 && typeof setImmediate === "function") {+ set = setImmediate;+ clear = clearImmediate;+ }+ return function (success) {+ var timedOut = false;+ var timer = set(function () {+ timedOut = true;+ success();+ }, millis);++ return function () {+ return function (s) {+ if (timedOut) {+ s(false);+ } else {+ clear(timer);+ s(true);+ }+ return nonCanceler;+ };+ };+ };+};++exports._unsafeInterleaveAff = function (aff) {+ return aff;+};++exports._forkAff = function (nonCanceler, aff) {+ var voidF = function () {};++ return function (success) {+ var canceler = aff(voidF, voidF);+ success(canceler);+ return nonCanceler;+ };+};++exports._forkAll = function (nonCanceler, foldl, affs) {+ var voidF = function () {};++ return function (success) {+ var cancelers = foldl(function (acc) {+ return function (aff) {+ acc.push(aff(voidF, voidF));+ return acc;+ };+ })([])(affs);++ var canceler = function (e) {+ return function (success, error) {+ var cancellations = 0;+ var result = false;+ var errored = false;++ var s = function (bool) {+ cancellations = cancellations + 1;+ result = result || bool;++ if (cancellations === cancelers.length && !errored) {+ success(result);+ }+ };++ var f = function (err) {+ if (!errored) {+ errored = true;+ error(err);+ }+ };++ for (var i = 0; i < cancelers.length; i++) {+ cancelers[i](e)(s, f);+ }++ return nonCanceler;+ };+ };++ success(canceler);+ return nonCanceler;+ };+};++exports._makeAff = function (cb) {+ return function (success, error) {+ try {+ return cb(function (e) {+ return function () {+ error(e);+ };+ })(function (v) {+ return function () {+ success(v);+ };+ })();+ } catch (err) {+ error(err);+ }+ };+};++exports._pure = function (nonCanceler, v) {+ return function (success) {+ success(v);+ return nonCanceler;+ };+};++exports._throwError = function (nonCanceler, e) {+ return function (success, error) {+ error(e);+ return nonCanceler;+ };+};++exports._fmap = function (f, aff) {+ return function (success, error) {+ return aff(function (v) {+ success(f(v));+ }, error);+ };+};++exports._bind = function (alwaysCanceler, aff, f) {+ return function (success, error) {+ var canceler1, canceler2;++ var isCanceled = false;+ var requestCancel = false;++ var onCanceler = function () {};++ canceler1 = aff(function (v) {+ if (requestCancel) {+ isCanceled = true;++ return alwaysCanceler;+ } else {+ canceler2 = f(v)(success, error);++ onCanceler(canceler2);++ return canceler2;+ }+ }, error);++ return function (e) {+ return function (s, f) {+ requestCancel = true;++ if (canceler2 !== undefined) {+ return canceler2(e)(s, f);+ } else {+ return canceler1(e)(function (bool) {+ if (bool || isCanceled) {+ s(true);+ } else {+ onCanceler = function (canceler) {+ canceler(e)(s, f);+ };+ }+ }, f);+ }+ };+ };+ };+};++exports._attempt = function (Left, Right, aff) {+ return function (success) {+ return aff(function (v) {+ success(Right(v));+ }, function (e) {+ success(Left(e));+ });+ };+};++exports._runAff = function (errorT, successT, aff) {+ // If errorT or successT throw, and an Aff is comprised only of synchronous+ // effects, then it's possible for makeAff/liftEff to accidentally catch+ // it, which may end up rerunning the Aff depending on error recovery+ // behavior. To mitigate this, we observe synchronicity using mutation. If+ // an Aff is observed to be synchronous, we let the stack reset and run the+ // handlers outside of the normal callback flow.+ return function () {+ var status = 0;+ var result, success;++ var canceler = aff(function (v) {+ if (status === 2) {+ successT(v)();+ } else {+ status = 1;+ result = v;+ success = true;+ }+ }, function (e) {+ if (status === 2) {+ errorT(e)();+ } else {+ status = 1;+ result = e;+ success = false;+ }+ });++ if (status === 1) {+ if (success) {+ successT(result)();+ } else {+ errorT(result)();+ }+ } else {+ status = 2;+ }++ return canceler;+ };+};++exports._liftEff = function (nonCanceler, e) {+ return function (success, error) {+ var result;+ try {+ result = e();+ } catch (err) {+ error(err);+ return nonCanceler;+ }++ success(result);+ return nonCanceler;+ };+};++exports._tailRecM = function (isLeft, f, a) {+ return function (success, error) {+ return function go (acc) {+ var result, status, canceler;++ // Observes synchronous effects using a flag.+ // status = 0 (unresolved status)+ // status = 1 (synchronous effect)+ // status = 2 (asynchronous effect)++ var csuccess = function (v) {+ // If the status is still unresolved, we have observed a+ // synchronous effect. Otherwise, the status will be `2`.+ if (status === 0) {+ // Store the result for further synchronous processing.+ result = v;+ status = 1;+ } else {+ // When we have observed an asynchronous effect, we use normal+ // recursion. This is safe because we will be on a new stack.+ if (isLeft(v)) {+ go(v.value0);+ } else {+ success(v.value0);+ }+ }+ };++ while (true) {+ status = 0;+ canceler = f(acc)(csuccess, error);++ // If the status has already resolved to `1` by our Aff handler, then+ // we have observed a synchronous effect. Otherwise it will still be+ // `0`.+ if (status === 1) {+ // When we have observed a synchronous effect, we merely swap out the+ // accumulator and continue the loop, preserving stack.+ if (isLeft(result)) {+ acc = result.value0;+ continue;+ } else {+ success(result.value0);+ }+ } else {+ // If the status has not resolved yet, then we have observed an+ // asynchronous effect.+ status = 2;+ }+ return canceler;+ }++ }(a);+ };+};++},{}],55:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Alt = require("../Control.Alt");+var Control_Alternative = require("../Control.Alternative");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Monad = require("../Control.Monad");+var Control_Monad_Aff_Internal = require("../Control.Monad.Aff.Internal");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var Control_Monad_Eff_Class = require("../Control.Monad.Eff.Class");+var Control_Monad_Eff_Exception = require("../Control.Monad.Eff.Exception");+var Control_Monad_Error_Class = require("../Control.Monad.Error.Class");+var Control_Monad_Rec_Class = require("../Control.Monad.Rec.Class");+var Control_MonadPlus = require("../Control.MonadPlus");+var Control_MonadZero = require("../Control.MonadZero");+var Control_Parallel = require("../Control.Parallel");+var Control_Parallel_Class = require("../Control.Parallel.Class");+var Control_Plus = require("../Control.Plus");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Either = require("../Data.Either");+var Data_Eq = require("../Data.Eq");+var Data_Foldable = require("../Data.Foldable");+var Data_Function = require("../Data.Function");+var Data_Function_Uncurried = require("../Data.Function.Uncurried");+var Data_Functor = require("../Data.Functor");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Monoid = require("../Data.Monoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Time_Duration = require("../Data.Time.Duration");+var Data_Tuple = require("../Data.Tuple");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var Unsafe_Coerce = require("../Unsafe.Coerce");+var ParAff = function (x) {+ return x;+};+var Canceler = function (x) {+ return x;+};+var runAff = function (ex) {+ return function (f) {+ return function (aff) {+ return $foreign._runAff(ex, f, aff);+ };+ };+};+var newtypeParAff = new Data_Newtype.Newtype(function (n) {+ return n;+}, ParAff);+var makeAff$prime = function (h) {+ return $foreign._makeAff(h);+};+var functorAff = new Data_Functor.Functor(function (f) {+ return function (fa) {+ return $foreign._fmap(f, fa);+ };+});+var functorParAff = functorAff;+var fromAVBox = Unsafe_Coerce.unsafeCoerce;+var cancel = function (v) {+ return v;+};+var launchAff = (function () {+ var lowerEx = Data_Functor.map(Control_Monad_Eff.functorEff)(function ($54) {+ return Canceler(Data_Functor.map(Data_Functor.functorFn)($foreign._unsafeInterleaveAff)(cancel($54)));+ });+ return function ($55) {+ return lowerEx(runAff(Control_Monad_Eff_Exception.throwException)(Data_Function["const"](Control_Applicative.pure(Control_Monad_Eff.applicativeEff)(Data_Unit.unit)))($foreign._unsafeInterleaveAff($55)));+ };+})();+var attempt = function (aff) {+ return $foreign._attempt(Data_Either.Left.create, Data_Either.Right.create, aff);+};+var apathize = function (a) {+ return Data_Functor.map(functorAff)(Data_Function["const"](Data_Unit.unit))(attempt(a));+};+var applyAff = new Control_Apply.Apply(function () {+ return functorAff;+}, function (ff) {+ return function (fa) {+ return $foreign._bind(alwaysCanceler, ff, function (f) {+ return Data_Functor.map(functorAff)(f)(fa);+ });+ };+});+var applicativeAff = new Control_Applicative.Applicative(function () {+ return applyAff;+}, function (v) {+ return $foreign._pure(nonCanceler, v);+});+var nonCanceler = Data_Function["const"](Control_Applicative.pure(applicativeAff)(false));+var alwaysCanceler = Data_Function["const"](Control_Applicative.pure(applicativeAff)(true));+var cancelWith = function (aff) {+ return function (c) {+ return $foreign._cancelWith(nonCanceler, aff, c);+ };+};+var delay = function (v) {+ return $foreign._delay(nonCanceler, v);+};+var forkAff = function (aff) {+ return $foreign._forkAff(nonCanceler, aff);+};+var forkAll = function (dictFoldable) {+ return function (affs) {+ return $foreign._forkAll(nonCanceler, Data_Foldable.foldl(dictFoldable), affs);+ };+};+var killVar = function (q) {+ return function (e) {+ return fromAVBox(Control_Monad_Aff_Internal._killVar(nonCanceler, q, e));+ };+};+var liftEff$prime = function (eff) {+ return attempt($foreign._unsafeInterleaveAff($foreign._liftEff(nonCanceler, eff)));+};+var makeAff = function (h) {+ return makeAff$prime(function (e) {+ return function (a) {+ return Data_Functor.map(Control_Monad_Eff.functorEff)(Data_Function["const"](nonCanceler))(h(e)(a));+ };+ });+};+var makeVar = fromAVBox(Control_Monad_Aff_Internal._makeVar(nonCanceler));+var putVar = function (q) {+ return function (a) {+ return fromAVBox(Control_Monad_Aff_Internal._putVar(nonCanceler, q, a));+ };+};+var takeVar = function (q) {+ return fromAVBox(Control_Monad_Aff_Internal._takeVar(nonCanceler, q));+};+var semigroupAff = function (dictSemigroup) {+ return new Data_Semigroup.Semigroup(function (a) {+ return function (b) {+ return Control_Apply.apply(applyAff)(Data_Functor.map(functorAff)(Data_Semigroup.append(dictSemigroup))(a))(b);+ };+ });+};+var monoidAff = function (dictMonoid) {+ return new Data_Monoid.Monoid(function () {+ return semigroupAff(dictMonoid.Semigroup0());+ }, Control_Applicative.pure(applicativeAff)(Data_Monoid.mempty(dictMonoid)));+};+var semigroupCanceler = new Data_Semigroup.Semigroup(function (v) {+ return function (v1) {+ return function (e) {+ return Control_Apply.apply(applyAff)(Data_Functor.map(functorAff)(Data_HeytingAlgebra.disj(Data_HeytingAlgebra.heytingAlgebraBoolean))(v(e)))(v1(e));+ };+ };+});+var monoidCanceler = new Data_Monoid.Monoid(function () {+ return semigroupCanceler;+}, Data_Function["const"](Control_Applicative.pure(applicativeAff)(true)));+var bindAff = new Control_Bind.Bind(function () {+ return applyAff;+}, function (fa) {+ return function (f) {+ return $foreign._bind(alwaysCanceler, fa, f);+ };+});+var applyParAff = new Control_Apply.Apply(function () {+ return functorParAff;+}, function (v) {+ return function (v1) {+ var putOrKill = function (v2) {+ return Data_Either.either(killVar(v2))(putVar(v2));+ };+ return Control_Bind.bind(bindAff)(makeVar)(function (v2) {+ return Control_Bind.bind(bindAff)(makeVar)(function (v3) {+ return Control_Bind.bind(bindAff)(forkAff(Control_Bind.bindFlipped(bindAff)(putOrKill(v2))(attempt(v))))(function (v4) {+ return Control_Bind.bind(bindAff)(forkAff(Control_Bind.bindFlipped(bindAff)(putOrKill(v3))(attempt(v1))))(function (v5) {+ return cancelWith(Control_Apply.apply(applyAff)(takeVar(v2))(takeVar(v3)))(Data_Semigroup.append(semigroupCanceler)(v4)(v5));+ });+ });+ });+ });+ };+});+var applicativeParAff = new Control_Applicative.Applicative(function () {+ return applyParAff;+}, function ($56) {+ return ParAff(Control_Applicative.pure(applicativeAff)($56));+});+var semigroupParAff = function (dictSemigroup) {+ return new Data_Semigroup.Semigroup(function (a) {+ return function (b) {+ return Control_Apply.apply(applyParAff)(Data_Functor.map(functorParAff)(Data_Semigroup.append(dictSemigroup))(a))(b);+ };+ });+};+var monoidParAff = function (dictMonoid) {+ return new Data_Monoid.Monoid(function () {+ return semigroupParAff(dictMonoid.Semigroup0());+ }, Control_Applicative.pure(applicativeParAff)(Data_Monoid.mempty(dictMonoid)));+};+var monadAff = new Control_Monad.Monad(function () {+ return applicativeAff;+}, function () {+ return bindAff;+});+var monadEffAff = new Control_Monad_Eff_Class.MonadEff(function () {+ return monadAff;+}, function (eff) {+ return $foreign._liftEff(nonCanceler, eff);+});+var monadRecAff = new Control_Monad_Rec_Class.MonadRec(function () {+ return monadAff;+}, function (f) {+ return function (a) {+ var isLoop = function (v) {+ if (v instanceof Control_Monad_Rec_Class.Loop) {+ return true;+ };+ return false;+ };+ return $foreign._tailRecM(isLoop, f, a);+ };+});+var monadThrowAff = new Control_Monad_Error_Class.MonadThrow(function () {+ return monadAff;+}, function (e) {+ return $foreign._throwError(nonCanceler, e);+});+var $$finally = function (aff1) {+ return function (aff2) {+ return Control_Bind.bind(bindAff)(attempt(aff1))(function (v) {+ return Control_Bind.bind(bindAff)(aff2)(function (v1) {+ return Data_Either.either(Control_Monad_Error_Class.throwError(monadThrowAff))(Control_Applicative.pure(applicativeAff))(v);+ });+ });+ };+};+var parallelParAff = new Control_Parallel_Class.Parallel(function () {+ return applicativeParAff;+}, function () {+ return monadAff;+}, ParAff, function (v) {+ return v;+});+var monadErrorAff = new Control_Monad_Error_Class.MonadError(function () {+ return monadThrowAff;+}, function (aff) {+ return function (ex) {+ return Control_Bind.bind(bindAff)(attempt(aff))(Data_Either.either(ex)(Control_Applicative.pure(applicativeAff)));+ };+});+var altParAff = new Control_Alt.Alt(function () {+ return functorParAff;+}, function (v) {+ return function (v1) {+ var maybeKill = function (va) {+ return function (ve) {+ return function (err) {+ return Control_Bind.bind(bindAff)(takeVar(ve))(function (v2) {+ return Control_Bind.discard(Control_Bind.discardUnit)(bindAff)(Control_Applicative.when(applicativeAff)(v2 === 1)(killVar(va)(err)))(function () {+ return putVar(ve)(v2 + 1 | 0);+ });+ });+ };+ };+ };+ var done = function (cs) {+ return function (get) {+ return function (va) {+ return function (x) {+ return Control_Bind.discard(Control_Bind.discardUnit)(bindAff)(putVar(va)(x))(function () {+ return Control_Bind.bind(bindAff)(Data_Functor.map(functorAff)(get)(takeVar(cs)))(function (v2) {+ return Data_Functor["void"](functorAff)(cancel(v2)(Control_Monad_Eff_Exception.error("Alt early exit")));+ });+ });+ };+ };+ };+ };+ return Control_Bind.bind(bindAff)(makeVar)(function (v2) {+ return Control_Bind.bind(bindAff)(makeVar)(function (v3) {+ return Control_Bind.bind(bindAff)(makeVar)(function (v4) {+ return Control_Bind.discard(Control_Bind.discardUnit)(bindAff)(putVar(v3)(0))(function () {+ return Control_Bind.bind(bindAff)(forkAff(Control_Bind.bindFlipped(bindAff)(Data_Either.either(maybeKill(v2)(v3))(done(v4)(Data_Tuple.snd)(v2)))(attempt(v))))(function (v5) {+ return Control_Bind.bind(bindAff)(forkAff(Control_Bind.bindFlipped(bindAff)(Data_Either.either(maybeKill(v2)(v3))(done(v4)(Data_Tuple.fst)(v2)))(attempt(v1))))(function (v6) {+ return Control_Bind.discard(Control_Bind.discardUnit)(bindAff)(putVar(v4)(new Data_Tuple.Tuple(v5, v6)))(function () {+ return cancelWith(takeVar(v2))(Data_Semigroup.append(semigroupCanceler)(v5)(v6));+ });+ });+ });+ });+ });+ });+ });+ };+});+var altAff = new Control_Alt.Alt(function () {+ return functorAff;+}, function (a1) {+ return function (a2) {+ return Control_Bind.bind(bindAff)(attempt(a1))(Data_Either.either(Data_Function["const"](a2))(Control_Applicative.pure(applicativeAff)));+ };+});+var plusAff = new Control_Plus.Plus(function () {+ return altAff;+}, Control_Monad_Error_Class.throwError(monadThrowAff)(Control_Monad_Eff_Exception.error("Always fails")));+var alternativeAff = new Control_Alternative.Alternative(function () {+ return applicativeAff;+}, function () {+ return plusAff;+});+var monadZero = new Control_MonadZero.MonadZero(function () {+ return alternativeAff;+}, function () {+ return monadAff;+});+var monadPlusAff = new Control_MonadPlus.MonadPlus(function () {+ return monadZero;+});+var plusParAff = new Control_Plus.Plus(function () {+ return altParAff;+}, Control_Plus.empty(plusAff));+var alternativeParAff = new Control_Alternative.Alternative(function () {+ return applicativeParAff;+}, function () {+ return plusParAff;+});+module.exports = {+ Canceler: Canceler, + ParAff: ParAff, + apathize: apathize, + attempt: attempt, + cancel: cancel, + cancelWith: cancelWith, + delay: delay, + "finally": $$finally, + forkAff: forkAff, + forkAll: forkAll, + launchAff: launchAff, + "liftEff'": liftEff$prime, + makeAff: makeAff, + "makeAff'": makeAff$prime, + nonCanceler: nonCanceler, + runAff: runAff, + semigroupAff: semigroupAff, + monoidAff: monoidAff, + functorAff: functorAff, + applyAff: applyAff, + applicativeAff: applicativeAff, + bindAff: bindAff, + monadAff: monadAff, + monadEffAff: monadEffAff, + monadThrowAff: monadThrowAff, + monadErrorAff: monadErrorAff, + altAff: altAff, + plusAff: plusAff, + alternativeAff: alternativeAff, + monadZero: monadZero, + monadPlusAff: monadPlusAff, + monadRecAff: monadRecAff, + semigroupCanceler: semigroupCanceler, + monoidCanceler: monoidCanceler, + newtypeParAff: newtypeParAff, + semigroupParAff: semigroupParAff, + monoidParAff: monoidParAff, + functorParAff: functorParAff, + applyParAff: applyParAff, + applicativeParAff: applicativeParAff, + altParAff: altParAff, + plusParAff: plusParAff, + alternativeParAff: alternativeParAff, + parallelParAff: parallelParAff+};++},{"../Control.Alt":38,"../Control.Alternative":39,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Monad":86,"../Control.Monad.Aff.Internal":53,"../Control.Monad.Eff":70,"../Control.Monad.Eff.Class":58,"../Control.Monad.Eff.Exception":62,"../Control.Monad.Error.Class":71,"../Control.Monad.Rec.Class":77,"../Control.MonadPlus":87,"../Control.MonadZero":88,"../Control.Parallel":90,"../Control.Parallel.Class":89,"../Control.Plus":91,"../Control.Semigroupoid":92,"../Data.Either":136,"../Data.Eq":138,"../Data.Foldable":143,"../Data.Function":149,"../Data.Function.Uncurried":148,"../Data.Functor":155,"../Data.HeytingAlgebra":160,"../Data.Monoid":207,"../Data.Newtype":209,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Time.Duration":242,"../Data.Tuple":245,"../Data.Unit":249,"../Prelude":268,"../Unsafe.Coerce":271,"./foreign":54}],56:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Prelude = require("../Prelude");+var MonadCont = function (Monad0, callCC) {+ this.Monad0 = Monad0;+ this.callCC = callCC;+};+var callCC = function (dict) {+ return dict.callCC;+};+module.exports = {+ MonadCont: MonadCont, + callCC: callCC+};++},{"../Prelude":268}],57:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Monad = require("../Control.Monad");+var Control_Monad_Cont_Class = require("../Control.Monad.Cont.Class");+var Control_Monad_Eff_Class = require("../Control.Monad.Eff.Class");+var Control_Monad_Reader_Class = require("../Control.Monad.Reader.Class");+var Control_Monad_State_Class = require("../Control.Monad.State.Class");+var Control_Monad_Trans_Class = require("../Control.Monad.Trans.Class");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Newtype = require("../Data.Newtype");+var Prelude = require("../Prelude");+var ContT = function (x) {+ return x;+};+var withContT = function (f) {+ return function (v) {+ return function (k) {+ return v(f(k));+ };+ };+};+var runContT = function (v) {+ return function (k) {+ return v(k);+ };+};+var newtypeContT = new Data_Newtype.Newtype(function (n) {+ return n;+}, ContT);+var monadTransContT = new Control_Monad_Trans_Class.MonadTrans(function (dictMonad) {+ return function (m) {+ return function (k) {+ return Control_Bind.bind(dictMonad.Bind1())(m)(k);+ };+ };+});+var mapContT = function (f) {+ return function (v) {+ return function (k) {+ return f(v(k));+ };+ };+};+var functorContT = function (dictFunctor) {+ return new Data_Functor.Functor(function (f) {+ return function (v) {+ return function (k) {+ return v(function (a) {+ return k(f(a));+ });+ };+ };+ });+};+var applyContT = function (dictApply) {+ return new Control_Apply.Apply(function () {+ return functorContT(dictApply.Functor0());+ }, function (v) {+ return function (v1) {+ return function (k) {+ return v(function (g) {+ return v1(function (a) {+ return k(g(a));+ });+ });+ };+ };+ });+};+var bindContT = function (dictBind) {+ return new Control_Bind.Bind(function () {+ return applyContT(dictBind.Apply0());+ }, function (v) {+ return function (k) {+ return function (k$prime) {+ return v(function (a) {+ var v1 = k(a);+ return v1(k$prime);+ });+ };+ };+ });+};+var applicativeContT = function (dictApplicative) {+ return new Control_Applicative.Applicative(function () {+ return applyContT(dictApplicative.Apply0());+ }, function (a) {+ return function (k) {+ return k(a);+ };+ });+};+var monadContT = function (dictMonad) {+ return new Control_Monad.Monad(function () {+ return applicativeContT(dictMonad.Applicative0());+ }, function () {+ return bindContT(dictMonad.Bind1());+ });+};+var monadAskContT = function (dictMonadAsk) {+ return new Control_Monad_Reader_Class.MonadAsk(function () {+ return monadContT(dictMonadAsk.Monad0());+ }, Control_Monad_Trans_Class.lift(monadTransContT)(dictMonadAsk.Monad0())(Control_Monad_Reader_Class.ask(dictMonadAsk)));+};+var monadReaderContT = function (dictMonadReader) {+ return new Control_Monad_Reader_Class.MonadReader(function () {+ return monadAskContT(dictMonadReader.MonadAsk0());+ }, function (f) {+ return function (v) {+ return function (k) {+ return Control_Bind.bind(((dictMonadReader.MonadAsk0()).Monad0()).Bind1())(Control_Monad_Reader_Class.ask(dictMonadReader.MonadAsk0()))(function (v1) {+ return Control_Monad_Reader_Class.local(dictMonadReader)(f)(v(function ($45) {+ return Control_Monad_Reader_Class.local(dictMonadReader)(Data_Function["const"](v1))(k($45));+ }));+ });+ };+ };+ });+};+var monadContContT = function (dictMonad) {+ return new Control_Monad_Cont_Class.MonadCont(function () {+ return monadContT(dictMonad);+ }, function (f) {+ return function (k) {+ var v = f(function (a) {+ return function (v1) {+ return k(a);+ };+ });+ return v(k);+ };+ });+};+var monadEffContT = function (dictMonadEff) {+ return new Control_Monad_Eff_Class.MonadEff(function () {+ return monadContT(dictMonadEff.Monad0());+ }, function ($46) {+ return Control_Monad_Trans_Class.lift(monadTransContT)(dictMonadEff.Monad0())(Control_Monad_Eff_Class.liftEff(dictMonadEff)($46));+ });+};+var monadStateContT = function (dictMonadState) {+ return new Control_Monad_State_Class.MonadState(function () {+ return monadContT(dictMonadState.Monad0());+ }, function ($47) {+ return Control_Monad_Trans_Class.lift(monadTransContT)(dictMonadState.Monad0())(Control_Monad_State_Class.state(dictMonadState)($47));+ });+};+module.exports = {+ ContT: ContT, + mapContT: mapContT, + runContT: runContT, + withContT: withContT, + newtypeContT: newtypeContT, + monadContContT: monadContContT, + functorContT: functorContT, + applyContT: applyContT, + applicativeContT: applicativeContT, + bindContT: bindContT, + monadContT: monadContT, + monadTransContT: monadTransContT, + monadEffContT: monadEffContT, + monadAskContT: monadAskContT, + monadReaderContT: monadReaderContT, + monadStateContT: monadStateContT+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Monad":86,"../Control.Monad.Cont.Class":56,"../Control.Monad.Eff.Class":58,"../Control.Monad.Reader.Class":75,"../Control.Monad.State.Class":80,"../Control.Monad.Trans.Class":83,"../Control.Semigroupoid":92,"../Data.Function":149,"../Data.Functor":155,"../Data.Newtype":209,"../Prelude":268}],58:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var Control_Monad = require("../Control.Monad");+var Control_Monad_Eff = require("../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;+};+module.exports = {+ MonadEff: MonadEff, + liftEff: liftEff, + monadEffEff: monadEffEff+};++},{"../Control.Category":47,"../Control.Monad":86,"../Control.Monad.Eff":70}],59:[function(require,module,exports){+"use strict";++exports.log = function (s) {+ return function () {+ console.log(s);+ return {};+ };+};++exports.warn = function (s) {+ return function () {+ console.warn(s);+ return {};+ };+};++exports.error = function (s) {+ return function () {+ console.error(s);+ return {};+ };+};++exports.info = function (s) {+ return function () {+ console.info(s);+ return {};+ };+};++},{}],60:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var Data_Show = require("../Data.Show");+var Data_Unit = require("../Data.Unit");+var warnShow = function (dictShow) {+ return function (a) {+ return $foreign.warn(Data_Show.show(dictShow)(a));+ };+};+var logShow = function (dictShow) {+ return function (a) {+ return $foreign.log(Data_Show.show(dictShow)(a));+ };+};+var infoShow = function (dictShow) {+ return function (a) {+ return $foreign.info(Data_Show.show(dictShow)(a));+ };+};+var errorShow = function (dictShow) {+ return function (a) {+ return $foreign.error(Data_Show.show(dictShow)(a));+ };+};+module.exports = {+ errorShow: errorShow, + infoShow: infoShow, + logShow: logShow, + warnShow: warnShow, + error: $foreign.error, + info: $foreign.info, + log: $foreign.log, + warn: $foreign.warn+};++},{"../Control.Monad.Eff":70,"../Data.Show":233,"../Data.Unit":249,"./foreign":59}],61:[function(require,module,exports){+"use strict";++exports.showErrorImpl = function (err) {+ return err.stack || err.toString();+};++exports.error = function (msg) {+ return new Error(msg);+};++exports.message = function (e) {+ return e.message;+};++exports.stackImpl = function (just) {+ return function (nothing) {+ return function (e) {+ return e.stack ? just(e.stack) : nothing;+ };+ };+};++exports.throwException = function (e) {+ return function () {+ throw e;+ };+};++exports.catchException = function (c) {+ return function (t) {+ return function () {+ try {+ return t();+ } catch (e) {+ if (e instanceof Error || Object.prototype.toString.call(e) === "[object Error]") {+ return c(e)();+ } else {+ return c(new Error(e.toString()))();+ }+ }+ };+ };+};++},{}],62:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Applicative = require("../Control.Applicative");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Either = require("../Data.Either");+var Data_Functor = require("../Data.Functor");+var Data_Maybe = require("../Data.Maybe");+var Data_Show = require("../Data.Show");+var Prelude = require("../Prelude");+var $$try = function (action) {+ return $foreign.catchException(function ($0) {+ return Control_Applicative.pure(Control_Monad_Eff.applicativeEff)(Data_Either.Left.create($0));+ })(Data_Functor.map(Control_Monad_Eff.functorEff)(Data_Either.Right.create)(action));+};+var $$throw = function ($1) {+ return $foreign.throwException($foreign.error($1));+};+var stack = $foreign.stackImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+var showError = new Data_Show.Show($foreign.showErrorImpl);+module.exports = {+ stack: stack, + "throw": $$throw, + "try": $$try, + showError: showError, + catchException: $foreign.catchException, + error: $foreign.error, + message: $foreign.message, + throwException: $foreign.throwException+};++},{"../Control.Applicative":40,"../Control.Monad.Eff":70,"../Control.Semigroupoid":92,"../Data.Either":136,"../Data.Functor":155,"../Data.Maybe":198,"../Data.Show":233,"../Prelude":268,"./foreign":61}],63:[function(require,module,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.find = function(selector) {+ return function(ob) {+ return function() {+ return ob.find(selector);+ };+ };+};++exports.parent = function(ob) {+ return function() {+ return ob.parent();+ };+};++exports.closest = function(selector) {+ return function(ob) {+ return function() {+ return ob.closest(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.css = function(props) {+ return function(ob) {+ return function() {+ ob.css(props);+ };+ };+};++exports.hasClass = function(cls) {+ return function(ob) {+ return function() {+ return ob.hasClass(cls);+ };+ };+};++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.getProp = function(p) {+ return function(ob) {+ return function() {+ return ob.prop(p);+ };+ };+};++exports.append = function(ob1) {+ return function(ob) {+ return function() {+ ob.append(ob1);+ };+ };+};++exports.appendText = function(s) {+ return function(ob) {+ return function() {+ ob.append(s);+ };+ };+};++exports.body = function() {+ return jQuery(document.body);+};++exports.remove = function(ob) {+ return function() {+ ob.remove();+ };+};++exports.clear = function(ob) {+ return function() {+ ob.empty();+ };+};++exports.before = function(ob) {+ return function(ob1) {+ return function() {+ ob1.before(ob);+ };+ };+};++exports.getText = function(ob) {+ return function() {+ return ob.text();+ };+};++exports.setText = function(text) {+ return function(ob) {+ return function() {+ ob.text(text);+ };+ };+};++exports.getHtml = function(ob) {+ return function() {+ return ob.html();+ };+};++exports.setHtml = function(html) {+ return function(ob) {+ return function() {+ ob.html(html);+ };+ };+};++exports.getValue = function(ob) {+ return function() {+ return ob.val();+ };+};++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.toArray = function(ob) {+ return function() {+ var els = ob.toArray();+ var copy = [];+ for (var i = 0; i < els.length; i++) {+ copy.push(jQuery(els[i]));+ }+ return copy;+ };+};++exports.on = function(evt) {+ return function(act) {+ return function(ob) {+ return function() {+ ob.on(evt, function(e) {+ act(e)(jQuery(this))();+ });+ };+ };+ };+};++exports["on'"] = function(evt) {+ return function(sel) {+ return function(act) {+ return function(ob) {+ return function() {+ ob.on(evt, sel, function(e) {+ act(e)(jQuery(this))();+ });+ };+ };+ };+ };+};++exports.preventDefault = function(e) {+ return function() {+ e.preventDefault();+ };+};++exports.stopPropagation = function(e) {+ return function() {+ e.stopPropagation();+ };+};++exports.stopImmediatePropagation = function(e) {+ return function() {+ e.stopImmediatePropagation();+ };+};++exports.getTarget = function(e) {+ return function() {+ return jQuery(e.target);+ };+};++exports.getCurrentTarget = function(e) {+ return function() {+ return jQuery(e.currentTarget);+ };+};++exports.getPageX = function(e) {+ return function() {+ return jQuery(e.pageX);+ };+};++exports.getPageY = function(e) {+ return function() {+ return jQuery(e.pageY);+ };+};++exports.getWhich = function(e) {+ return function() {+ return jQuery(e.which);+ };+};++exports.getMetaKey = function(e) {+ return function() {+ return jQuery(e.metaKey);+ };+};+++exports.clone = function(ob) {+ return function() {+ return ob.clone();+ };+};++exports.cloneWithDataAndEvents = function(ob) {+ return function() {+ return ob.clone(true);+ };+};++},{}],64:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var DOM = require("../DOM");+var Data_Foreign = require("../Data.Foreign");+var Prelude = require("../Prelude");+var removeClass = function (cls) {+ return $foreign.setClass(cls)(false);+};+var hide = $foreign.setVisible(false);+var display = $foreign.setVisible(true);+var addClass = function (cls) {+ return $foreign.setClass(cls)(true);+};+module.exports = {+ addClass: addClass, + display: display, + hide: hide, + removeClass: removeClass, + append: $foreign.append, + appendText: $foreign.appendText, + attr: $foreign.attr, + before: $foreign.before, + body: $foreign.body, + clear: $foreign.clear, + clone: $foreign.clone, + cloneWithDataAndEvents: $foreign.cloneWithDataAndEvents, + closest: $foreign.closest, + create: $foreign.create, + css: $foreign.css, + find: $foreign.find, + getCurrentTarget: $foreign.getCurrentTarget, + getHtml: $foreign.getHtml, + getMetaKey: $foreign.getMetaKey, + getPageX: $foreign.getPageX, + getPageY: $foreign.getPageY, + getProp: $foreign.getProp, + getTarget: $foreign.getTarget, + getText: $foreign.getText, + getValue: $foreign.getValue, + getWhich: $foreign.getWhich, + hasClass: $foreign.hasClass, + on: $foreign.on, + "on'": $foreign["on'"], + parent: $foreign.parent, + preventDefault: $foreign.preventDefault, + ready: $foreign.ready, + remove: $foreign.remove, + select: $foreign.select, + setAttr: $foreign.setAttr, + setClass: $foreign.setClass, + setHtml: $foreign.setHtml, + setProp: $foreign.setProp, + setText: $foreign.setText, + setValue: $foreign.setValue, + setVisible: $foreign.setVisible, + stopImmediatePropagation: $foreign.stopImmediatePropagation, + stopPropagation: $foreign.stopPropagation, + toArray: $foreign.toArray, + toggle: $foreign.toggle, + toggleClass: $foreign.toggleClass+};++},{"../Control.Monad.Eff":70,"../DOM":100,"../Data.Foreign":145,"../Prelude":268,"./foreign":63}],65:[function(require,module,exports){+"use strict";++exports.newRef = function (val) {+ return function () {+ return { value: val };+ };+};++exports.readRef = function (ref) {+ return function () {+ return ref.value;+ };+};++exports["modifyRef'"] = function (ref) {+ return function (f) {+ return function () {+ var t = f(ref.value);+ ref.value = t.state;+ return t.value;+ };+ };+};++exports.writeRef = function (ref) {+ return function (val) {+ return function () {+ ref.value = val;+ return {};+ };+ };+};++},{}],66:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var modifyRef = function (ref) {+ return function (f) {+ return $foreign["modifyRef'"](ref)(function (s) {+ return {+ state: f(s), + value: Data_Unit.unit+ };+ });+ };+};+module.exports = {+ modifyRef: modifyRef, + "modifyRef'": $foreign["modifyRef'"], + newRef: $foreign.newRef, + readRef: $foreign.readRef, + writeRef: $foreign.writeRef+};++},{"../Control.Monad.Eff":70,"../Data.Unit":249,"../Prelude":268,"./foreign":65}],67:[function(require,module,exports){+"use strict";++exports.unsafeCoerceEff = function (f) {+ return f;+};++},{}],68:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var unsafePerformEff = function ($0) {+ return Control_Monad_Eff.runPure($foreign.unsafeCoerceEff($0));+};+module.exports = {+ unsafePerformEff: unsafePerformEff, + unsafeCoerceEff: $foreign.unsafeCoerceEff+};++},{"../Control.Monad.Eff":70,"../Control.Semigroupoid":92,"./foreign":67}],69:[function(require,module,exports){+"use strict";++exports.pureE = function (a) {+ return function () {+ return a;+ };+};++exports.bindE = function (a) {+ return function (f) {+ return function () {+ return f(a())();+ };+ };+};++exports.runPure = function (f) {+ return f();+};++exports.untilE = function (f) {+ return function () {+ while (!f());+ return {};+ };+};++exports.whileE = function (f) {+ return function (a) {+ return function () {+ while (f()) {+ a();+ }+ return {};+ };+ };+};++exports.forE = function (lo) {+ return function (hi) {+ return function (f) {+ return function () {+ for (var i = lo; i < hi; i++) {+ f(i)();+ }+ };+ };+ };+};++exports.foreachE = function (as) {+ return function (f) {+ return function () {+ for (var i = 0, l = as.length; i < l; i++) {+ f(as[i])();+ }+ };+ };+};++},{}],70:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Monad = require("../Control.Monad");+var Data_Functor = require("../Data.Functor");+var Data_Unit = require("../Data.Unit");+var monadEff = new Control_Monad.Monad(function () {+ return applicativeEff;+}, function () {+ return bindEff;+});+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));+module.exports = {+ functorEff: functorEff, + applyEff: applyEff, + applicativeEff: applicativeEff, + bindEff: bindEff, + monadEff: monadEff, + forE: $foreign.forE, + foreachE: $foreign.foreachE, + runPure: $foreign.runPure, + untilE: $foreign.untilE, + whileE: $foreign.whileE+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Monad":86,"../Data.Functor":155,"../Data.Unit":249,"./foreign":69}],71:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Bind = require("../Control.Bind");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Either = require("../Data.Either");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Maybe = require("../Data.Maybe");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var MonadThrow = function (Monad0, throwError) {+ this.Monad0 = Monad0;+ this.throwError = throwError;+};+var MonadError = function (MonadThrow0, catchError) {+ this.MonadThrow0 = MonadThrow0;+ this.catchError = catchError;+};+var throwError = function (dict) {+ return dict.throwError;+};+var monadThrowMaybe = new MonadThrow(function () {+ return Data_Maybe.monadMaybe;+}, Data_Function["const"](Data_Maybe.Nothing.value));+var monadThrowEither = new MonadThrow(function () {+ return Data_Either.monadEither;+}, Data_Either.Left.create);+var monadErrorMaybe = new MonadError(function () {+ return monadThrowMaybe;+}, function (v) {+ return function (v1) {+ if (v instanceof Data_Maybe.Nothing) {+ return v1(Data_Unit.unit);+ };+ if (v instanceof Data_Maybe.Just) {+ return new Data_Maybe.Just(v.value0);+ };+ throw new Error("Failed pattern match at Control.Monad.Error.Class line 77, column 3 - line 77, column 33: " + [ v.constructor.name, v1.constructor.name ]);+ };+});+var monadErrorEither = new MonadError(function () {+ return monadThrowEither;+}, function (v) {+ return function (v1) {+ if (v instanceof Data_Either.Left) {+ return v1(v.value0);+ };+ if (v instanceof Data_Either.Right) {+ return new Data_Either.Right(v.value0);+ };+ throw new Error("Failed pattern match at Control.Monad.Error.Class line 70, column 3 - line 70, column 30: " + [ v.constructor.name, v1.constructor.name ]);+ };+});+var catchError = function (dict) {+ return dict.catchError;+};+var catchJust = function (dictMonadError) {+ return function (p) {+ return function (act) {+ return function (handler) {+ var handle = function (e) {+ var v = p(e);+ if (v instanceof Data_Maybe.Nothing) {+ return throwError(dictMonadError.MonadThrow0())(e);+ };+ if (v instanceof Data_Maybe.Just) {+ return handler(v.value0);+ };+ throw new Error("Failed pattern match at Control.Monad.Error.Class line 54, column 5 - line 56, column 26: " + [ v.constructor.name ]);+ };+ return catchError(dictMonadError)(act)(handle);+ };+ };+ };+};+var $$try = function (dictMonadError) {+ return function (a) {+ return catchError(dictMonadError)(Data_Functor.map(((((dictMonadError.MonadThrow0()).Monad0()).Bind1()).Apply0()).Functor0())(Data_Either.Right.create)(a))(function ($21) {+ return Control_Applicative.pure(((dictMonadError.MonadThrow0()).Monad0()).Applicative0())(Data_Either.Left.create($21));+ });+ };+};+var withResource = function (dictMonadError) {+ return function (acquire) {+ return function (release) {+ return function (kleisli) {+ return Control_Bind.bind(((dictMonadError.MonadThrow0()).Monad0()).Bind1())(acquire)(function (v) {+ return Control_Bind.bind(((dictMonadError.MonadThrow0()).Monad0()).Bind1())($$try(dictMonadError)(kleisli(v)))(function (v1) {+ return Control_Bind.discard(Control_Bind.discardUnit)(((dictMonadError.MonadThrow0()).Monad0()).Bind1())(release(v))(function () {+ return Data_Either.either(throwError(dictMonadError.MonadThrow0()))(Control_Applicative.pure(((dictMonadError.MonadThrow0()).Monad0()).Applicative0()))(v1);+ });+ });+ });+ };+ };+ };+};+module.exports = {+ MonadError: MonadError, + MonadThrow: MonadThrow, + catchError: catchError, + catchJust: catchJust, + throwError: throwError, + "try": $$try, + withResource: withResource, + monadThrowEither: monadThrowEither, + monadErrorEither: monadErrorEither, + monadThrowMaybe: monadThrowMaybe, + monadErrorMaybe: monadErrorMaybe+};++},{"../Control.Applicative":40,"../Control.Bind":46,"../Control.Semigroupoid":92,"../Data.Either":136,"../Data.Function":149,"../Data.Functor":155,"../Data.Maybe":198,"../Data.Unit":249,"../Prelude":268}],72:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Control_Alternative = require("../Control.Alternative");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Category = require("../Control.Category");+var Control_Monad = require("../Control.Monad");+var Control_Monad_Cont_Class = require("../Control.Monad.Cont.Class");+var Control_Monad_Eff_Class = require("../Control.Monad.Eff.Class");+var Control_Monad_Error_Class = require("../Control.Monad.Error.Class");+var Control_Monad_Reader_Class = require("../Control.Monad.Reader.Class");+var Control_Monad_Rec_Class = require("../Control.Monad.Rec.Class");+var Control_Monad_State_Class = require("../Control.Monad.State.Class");+var Control_Monad_Trans_Class = require("../Control.Monad.Trans.Class");+var Control_Monad_Writer_Class = require("../Control.Monad.Writer.Class");+var Control_MonadPlus = require("../Control.MonadPlus");+var Control_MonadZero = require("../Control.MonadZero");+var Control_Plus = require("../Control.Plus");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Either = require("../Data.Either");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Monoid = require("../Data.Monoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var ExceptT = function (x) {+ return x;+};+var withExceptT = function (dictFunctor) {+ return function (f) {+ return function (v) {+ var mapLeft = function (v1) {+ return function (v2) {+ if (v2 instanceof Data_Either.Right) {+ return new Data_Either.Right(v2.value0);+ };+ if (v2 instanceof Data_Either.Left) {+ return new Data_Either.Left(v1(v2.value0));+ };+ throw new Error("Failed pattern match at Control.Monad.Except.Trans line 44, column 3 - line 44, column 32: " + [ v1.constructor.name, v2.constructor.name ]);+ };+ };+ return ExceptT(Data_Functor.map(dictFunctor)(mapLeft(f))(v));+ };+ };+};+var runExceptT = function (v) {+ return v;+};+var newtypeExceptT = new Data_Newtype.Newtype(function (n) {+ return n;+}, ExceptT);+var monadTransExceptT = new Control_Monad_Trans_Class.MonadTrans(function (dictMonad) {+ return function (m) {+ return Control_Bind.bind(dictMonad.Bind1())(m)(function (v) {+ return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Either.Right(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 except = function (dictApplicative) {+ return function ($96) {+ return ExceptT(Control_Applicative.pure(dictApplicative)($96));+ };+};+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 monadAskExceptT = function (dictMonadAsk) {+ return new Control_Monad_Reader_Class.MonadAsk(function () {+ return monadExceptT(dictMonadAsk.Monad0());+ }, Control_Monad_Trans_Class.lift(monadTransExceptT)(dictMonadAsk.Monad0())(Control_Monad_Reader_Class.ask(dictMonadAsk)));+};+var monadReaderExceptT = function (dictMonadReader) {+ return new Control_Monad_Reader_Class.MonadReader(function () {+ return monadAskExceptT(dictMonadReader.MonadAsk0());+ }, function (f) {+ return mapExceptT(Control_Monad_Reader_Class.local(dictMonadReader)(f));+ });+};+var monadContExceptT = function (dictMonadCont) {+ return new Control_Monad_Cont_Class.MonadCont(function () {+ return monadExceptT(dictMonadCont.Monad0());+ }, function (f) {+ return ExceptT(Control_Monad_Cont_Class.callCC(dictMonadCont)(function (c) {+ var v = f(function (a) {+ return ExceptT(c(new Data_Either.Right(a)));+ });+ return v;+ }));+ });+};+var monadEffExceptT = function (dictMonadEff) {+ return new Control_Monad_Eff_Class.MonadEff(function () {+ return monadExceptT(dictMonadEff.Monad0());+ }, function ($99) {+ return Control_Monad_Trans_Class.lift(monadTransExceptT)(dictMonadEff.Monad0())(Control_Monad_Eff_Class.liftEff(dictMonadEff)($99));+ });+};+var monadRecExceptT = function (dictMonadRec) {+ return new Control_Monad_Rec_Class.MonadRec(function () {+ return monadExceptT(dictMonadRec.Monad0());+ }, function (f) {+ return function ($100) {+ return ExceptT(Control_Monad_Rec_Class.tailRecM(dictMonadRec)(function (a) {+ return Control_Bind.bind((dictMonadRec.Monad0()).Bind1())((function () {+ var v = f(a);+ return v;+ })())(function (m$prime) {+ return Control_Applicative.pure((dictMonadRec.Monad0()).Applicative0())((function () {+ if (m$prime instanceof Data_Either.Left) {+ return new Control_Monad_Rec_Class.Done(new Data_Either.Left(m$prime.value0));+ };+ if (m$prime instanceof Data_Either.Right && m$prime.value0 instanceof Control_Monad_Rec_Class.Loop) {+ return new Control_Monad_Rec_Class.Loop(m$prime.value0.value0);+ };+ if (m$prime instanceof Data_Either.Right && m$prime.value0 instanceof Control_Monad_Rec_Class.Done) {+ return new Control_Monad_Rec_Class.Done(new Data_Either.Right(m$prime.value0.value0));+ };+ throw new Error("Failed pattern match at Control.Monad.Except.Trans line 76, column 14 - line 79, column 43: " + [ m$prime.constructor.name ]);+ })());+ });+ })($100));+ };+ });+};+var monadStateExceptT = function (dictMonadState) {+ return new Control_Monad_State_Class.MonadState(function () {+ return monadExceptT(dictMonadState.Monad0());+ }, function (f) {+ return Control_Monad_Trans_Class.lift(monadTransExceptT)(dictMonadState.Monad0())(Control_Monad_State_Class.state(dictMonadState)(f));+ });+};+var monadTellExceptT = function (dictMonadTell) {+ return new Control_Monad_Writer_Class.MonadTell(function () {+ return monadExceptT(dictMonadTell.Monad0());+ }, function ($101) {+ return Control_Monad_Trans_Class.lift(monadTransExceptT)(dictMonadTell.Monad0())(Control_Monad_Writer_Class.tell(dictMonadTell)($101));+ });+};+var monadWriterExceptT = function (dictMonadWriter) {+ return new Control_Monad_Writer_Class.MonadWriter(function () {+ return monadTellExceptT(dictMonadWriter.MonadTell0());+ }, mapExceptT(function (m) {+ return Control_Bind.bind(((dictMonadWriter.MonadTell0()).Monad0()).Bind1())(Control_Monad_Writer_Class.listen(dictMonadWriter)(m))(function (v) {+ return Control_Applicative.pure(((dictMonadWriter.MonadTell0()).Monad0()).Applicative0())(Data_Functor.map(Data_Either.functorEither)(function (r) {+ return new Data_Tuple.Tuple(r, v.value1);+ })(v.value0));+ });+ }), mapExceptT(function (m) {+ return Control_Monad_Writer_Class.pass(dictMonadWriter)(Control_Bind.bind(((dictMonadWriter.MonadTell0()).Monad0()).Bind1())(m)(function (v) {+ return Control_Applicative.pure(((dictMonadWriter.MonadTell0()).Monad0()).Applicative0())((function () {+ if (v instanceof Data_Either.Left) {+ return new Data_Tuple.Tuple(new Data_Either.Left(v.value0), Control_Category.id(Control_Category.categoryFn));+ };+ if (v instanceof Data_Either.Right) {+ return new Data_Tuple.Tuple(new Data_Either.Right(v.value0.value0), v.value0.value1);+ };+ throw new Error("Failed pattern match at Control.Monad.Except.Trans line 138, column 10 - line 140, column 44: " + [ v.constructor.name ]);+ })());+ }));+ }));+};+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 monadErrorExceptT = function (dictMonad) {+ return new Control_Monad_Error_Class.MonadError(function () {+ return monadThrowExceptT(dictMonad);+ }, function (v) {+ return function (k) {+ return Control_Bind.bind(dictMonad.Bind1())(v)(Data_Either.either(function (a) {+ var v1 = k(a);+ return v1;+ })(function ($103) {+ return Control_Applicative.pure(dictMonad.Applicative0())(Data_Either.Right.create($103));+ }));+ };+ });+};+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 ]);+ });+ };+ });+ };+};+var plusExceptT = function (dictMonoid) {+ return function (dictMonad) {+ return new Control_Plus.Plus(function () {+ return altExceptT(dictMonoid.Semigroup0())(dictMonad);+ }, Control_Monad_Error_Class.throwError(monadThrowExceptT(dictMonad))(Data_Monoid.mempty(dictMonoid)));+ };+};+var alternativeExceptT = function (dictMonoid) {+ return function (dictMonad) {+ return new Control_Alternative.Alternative(function () {+ return applicativeExceptT(dictMonad);+ }, function () {+ return plusExceptT(dictMonoid)(dictMonad);+ });+ };+};+var monadZeroExceptT = function (dictMonoid) {+ return function (dictMonad) {+ return new Control_MonadZero.MonadZero(function () {+ return alternativeExceptT(dictMonoid)(dictMonad);+ }, function () {+ return monadExceptT(dictMonad);+ });+ };+};+var monadPlusExceptT = function (dictMonoid) {+ return function (dictMonad) {+ return new Control_MonadPlus.MonadPlus(function () {+ return monadZeroExceptT(dictMonoid)(dictMonad);+ });+ };+};+module.exports = {+ ExceptT: ExceptT, + except: except, + mapExceptT: mapExceptT, + runExceptT: runExceptT, + withExceptT: withExceptT, + newtypeExceptT: newtypeExceptT, + functorExceptT: functorExceptT, + applyExceptT: applyExceptT, + applicativeExceptT: applicativeExceptT, + bindExceptT: bindExceptT, + monadExceptT: monadExceptT, + monadRecExceptT: monadRecExceptT, + altExceptT: altExceptT, + plusExceptT: plusExceptT, + alternativeExceptT: alternativeExceptT, + monadPlusExceptT: monadPlusExceptT, + monadZeroExceptT: monadZeroExceptT, + monadTransExceptT: monadTransExceptT, + monadEffExceptT: monadEffExceptT, + monadContExceptT: monadContExceptT, + monadThrowExceptT: monadThrowExceptT, + monadErrorExceptT: monadErrorExceptT, + monadAskExceptT: monadAskExceptT, + monadReaderExceptT: monadReaderExceptT, + monadStateExceptT: monadStateExceptT, + monadTellExceptT: monadTellExceptT, + monadWriterExceptT: monadWriterExceptT+};++},{"../Control.Alt":38,"../Control.Alternative":39,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Category":47,"../Control.Monad":86,"../Control.Monad.Cont.Class":56,"../Control.Monad.Eff.Class":58,"../Control.Monad.Error.Class":71,"../Control.Monad.Reader.Class":75,"../Control.Monad.Rec.Class":77,"../Control.Monad.State.Class":80,"../Control.Monad.Trans.Class":83,"../Control.Monad.Writer.Class":84,"../Control.MonadPlus":87,"../Control.MonadZero":88,"../Control.Plus":91,"../Control.Semigroupoid":92,"../Data.Either":136,"../Data.Function":149,"../Data.Functor":155,"../Data.Monoid":207,"../Data.Newtype":209,"../Data.Semigroup":229,"../Data.Tuple":245,"../Prelude":268}],73:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Monad_Error_Class = require("../Control.Monad.Error.Class");+var Control_Monad_Except_Trans = require("../Control.Monad.Except.Trans");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Either = require("../Data.Either");+var Data_Identity = require("../Data.Identity");+var Data_Newtype = require("../Data.Newtype");+var Prelude = require("../Prelude");+var withExcept = Control_Monad_Except_Trans.withExceptT(Data_Identity.functorIdentity);+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)));+ });+};+module.exports = {+ mapExcept: mapExcept, + runExcept: runExcept, + withExcept: withExcept+};++},{"../Control.Monad.Error.Class":71,"../Control.Monad.Except.Trans":72,"../Control.Semigroupoid":92,"../Data.Either":136,"../Data.Identity":161,"../Data.Newtype":209,"../Prelude":268}],74:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Control_Alternative = require("../Control.Alternative");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Category = require("../Control.Category");+var Control_Monad = require("../Control.Monad");+var Control_Monad_Cont_Class = require("../Control.Monad.Cont.Class");+var Control_Monad_Eff_Class = require("../Control.Monad.Eff.Class");+var Control_Monad_Error_Class = require("../Control.Monad.Error.Class");+var Control_Monad_Reader_Class = require("../Control.Monad.Reader.Class");+var Control_Monad_Rec_Class = require("../Control.Monad.Rec.Class");+var Control_Monad_State_Class = require("../Control.Monad.State.Class");+var Control_Monad_Trans_Class = require("../Control.Monad.Trans.Class");+var Control_Monad_Writer_Class = require("../Control.Monad.Writer.Class");+var Control_MonadPlus = require("../Control.MonadPlus");+var Control_MonadZero = require("../Control.MonadZero");+var Control_Plus = require("../Control.Plus");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Maybe = require("../Data.Maybe");+var Data_Newtype = require("../Data.Newtype");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var MaybeT = function (x) {+ return x;+};+var runMaybeT = function (v) {+ return v;+};+var newtypeMaybeT = new Data_Newtype.Newtype(function (n) {+ return n;+}, MaybeT);+var monadTransMaybeT = new Control_Monad_Trans_Class.MonadTrans(function (dictMonad) {+ return function ($75) {+ return MaybeT(Control_Monad.liftM1(dictMonad)(Data_Maybe.Just.create)($75));+ };+});+var mapMaybeT = function (f) {+ return function (v) {+ return f(v);+ };+};+var functorMaybeT = function (dictFunctor) {+ return new Data_Functor.Functor(function (f) {+ return function (v) {+ return Data_Functor.map(dictFunctor)(Data_Functor.map(Data_Maybe.functorMaybe)(f))(v);+ };+ });+};+var monadMaybeT = function (dictMonad) {+ return new Control_Monad.Monad(function () {+ return applicativeMaybeT(dictMonad);+ }, function () {+ return bindMaybeT(dictMonad);+ });+};+var bindMaybeT = function (dictMonad) {+ return new Control_Bind.Bind(function () {+ return applyMaybeT(dictMonad);+ }, function (v) {+ return function (f) {+ return Control_Bind.bind(dictMonad.Bind1())(v)(function (v1) {+ if (v1 instanceof Data_Maybe.Nothing) {+ return Control_Applicative.pure(dictMonad.Applicative0())(Data_Maybe.Nothing.value);+ };+ if (v1 instanceof Data_Maybe.Just) {+ var v2 = f(v1.value0);+ return v2;+ };+ throw new Error("Failed pattern match at Control.Monad.Maybe.Trans line 55, column 11 - line 57, column 42: " + [ v1.constructor.name ]);+ });+ };+ });+};+var applyMaybeT = function (dictMonad) {+ return new Control_Apply.Apply(function () {+ return functorMaybeT(((dictMonad.Bind1()).Apply0()).Functor0());+ }, Control_Monad.ap(monadMaybeT(dictMonad)));+};+var applicativeMaybeT = function (dictMonad) {+ return new Control_Applicative.Applicative(function () {+ return applyMaybeT(dictMonad);+ }, function ($76) {+ return MaybeT(Control_Applicative.pure(dictMonad.Applicative0())(Data_Maybe.Just.create($76)));+ });+};+var monadAskMaybeT = function (dictMonadAsk) {+ return new Control_Monad_Reader_Class.MonadAsk(function () {+ return monadMaybeT(dictMonadAsk.Monad0());+ }, Control_Monad_Trans_Class.lift(monadTransMaybeT)(dictMonadAsk.Monad0())(Control_Monad_Reader_Class.ask(dictMonadAsk)));+};+var monadReaderMaybeT = function (dictMonadReader) {+ return new Control_Monad_Reader_Class.MonadReader(function () {+ return monadAskMaybeT(dictMonadReader.MonadAsk0());+ }, function (f) {+ return mapMaybeT(Control_Monad_Reader_Class.local(dictMonadReader)(f));+ });+};+var monadContMaybeT = function (dictMonadCont) {+ return new Control_Monad_Cont_Class.MonadCont(function () {+ return monadMaybeT(dictMonadCont.Monad0());+ }, function (f) {+ return MaybeT(Control_Monad_Cont_Class.callCC(dictMonadCont)(function (c) {+ var v = f(function (a) {+ return MaybeT(c(new Data_Maybe.Just(a)));+ });+ return v;+ }));+ });+};+var monadEffMaybe = function (dictMonadEff) {+ return new Control_Monad_Eff_Class.MonadEff(function () {+ return monadMaybeT(dictMonadEff.Monad0());+ }, function ($77) {+ return Control_Monad_Trans_Class.lift(monadTransMaybeT)(dictMonadEff.Monad0())(Control_Monad_Eff_Class.liftEff(dictMonadEff)($77));+ });+};+var monadRecMaybeT = function (dictMonadRec) {+ return new Control_Monad_Rec_Class.MonadRec(function () {+ return monadMaybeT(dictMonadRec.Monad0());+ }, function (f) {+ return function ($78) {+ return MaybeT(Control_Monad_Rec_Class.tailRecM(dictMonadRec)(function (a) {+ return Control_Bind.bind((dictMonadRec.Monad0()).Bind1())((function () {+ var v = f(a);+ return v;+ })())(function (m$prime) {+ return Control_Applicative.pure((dictMonadRec.Monad0()).Applicative0())((function () {+ if (m$prime instanceof Data_Maybe.Nothing) {+ return new Control_Monad_Rec_Class.Done(Data_Maybe.Nothing.value);+ };+ if (m$prime instanceof Data_Maybe.Just && m$prime.value0 instanceof Control_Monad_Rec_Class.Loop) {+ return new Control_Monad_Rec_Class.Loop(m$prime.value0.value0);+ };+ if (m$prime instanceof Data_Maybe.Just && m$prime.value0 instanceof Control_Monad_Rec_Class.Done) {+ return new Control_Monad_Rec_Class.Done(new Data_Maybe.Just(m$prime.value0.value0));+ };+ throw new Error("Failed pattern match at Control.Monad.Maybe.Trans line 85, column 16 - line 88, column 43: " + [ m$prime.constructor.name ]);+ })());+ });+ })($78));+ };+ });+};+var monadStateMaybeT = function (dictMonadState) {+ return new Control_Monad_State_Class.MonadState(function () {+ return monadMaybeT(dictMonadState.Monad0());+ }, function (f) {+ return Control_Monad_Trans_Class.lift(monadTransMaybeT)(dictMonadState.Monad0())(Control_Monad_State_Class.state(dictMonadState)(f));+ });+};+var monadTellMaybeT = function (dictMonadTell) {+ return new Control_Monad_Writer_Class.MonadTell(function () {+ return monadMaybeT(dictMonadTell.Monad0());+ }, function ($79) {+ return Control_Monad_Trans_Class.lift(monadTransMaybeT)(dictMonadTell.Monad0())(Control_Monad_Writer_Class.tell(dictMonadTell)($79));+ });+};+var monadWriterMaybeT = function (dictMonadWriter) {+ return new Control_Monad_Writer_Class.MonadWriter(function () {+ return monadTellMaybeT(dictMonadWriter.MonadTell0());+ }, mapMaybeT(function (m) {+ return Control_Bind.bind(((dictMonadWriter.MonadTell0()).Monad0()).Bind1())(Control_Monad_Writer_Class.listen(dictMonadWriter)(m))(function (v) {+ return Control_Applicative.pure(((dictMonadWriter.MonadTell0()).Monad0()).Applicative0())(Data_Functor.map(Data_Maybe.functorMaybe)(function (r) {+ return new Data_Tuple.Tuple(r, v.value1);+ })(v.value0));+ });+ }), mapMaybeT(function (m) {+ return Control_Monad_Writer_Class.pass(dictMonadWriter)(Control_Bind.bind(((dictMonadWriter.MonadTell0()).Monad0()).Bind1())(m)(function (v) {+ return Control_Applicative.pure(((dictMonadWriter.MonadTell0()).Monad0()).Applicative0())((function () {+ if (v instanceof Data_Maybe.Nothing) {+ return new Data_Tuple.Tuple(Data_Maybe.Nothing.value, Control_Category.id(Control_Category.categoryFn));+ };+ if (v instanceof Data_Maybe.Just) {+ return new Data_Tuple.Tuple(new Data_Maybe.Just(v.value0.value0), v.value0.value1);+ };+ throw new Error("Failed pattern match at Control.Monad.Maybe.Trans line 122, column 10 - line 124, column 42: " + [ v.constructor.name ]);+ })());+ }));+ }));+};+var monadThrowMaybeT = function (dictMonadThrow) {+ return new Control_Monad_Error_Class.MonadThrow(function () {+ return monadMaybeT(dictMonadThrow.Monad0());+ }, function (e) {+ return Control_Monad_Trans_Class.lift(monadTransMaybeT)(dictMonadThrow.Monad0())(Control_Monad_Error_Class.throwError(dictMonadThrow)(e));+ });+};+var monadErrorMaybeT = function (dictMonadError) {+ return new Control_Monad_Error_Class.MonadError(function () {+ return monadThrowMaybeT(dictMonadError.MonadThrow0());+ }, function (v) {+ return function (h) {+ return MaybeT(Control_Monad_Error_Class.catchError(dictMonadError)(v)(function (a) {+ var v1 = h(a);+ return v1;+ }));+ };+ });+};+var altMaybeT = function (dictMonad) {+ return new Control_Alt.Alt(function () {+ return functorMaybeT(((dictMonad.Bind1()).Apply0()).Functor0());+ }, function (v) {+ return function (v1) {+ return Control_Bind.bind(dictMonad.Bind1())(v)(function (v2) {+ if (v2 instanceof Data_Maybe.Nothing) {+ return v1;+ };+ return Control_Applicative.pure(dictMonad.Applicative0())(v2);+ });+ };+ });+};+var plusMaybeT = function (dictMonad) {+ return new Control_Plus.Plus(function () {+ return altMaybeT(dictMonad);+ }, Control_Applicative.pure(dictMonad.Applicative0())(Data_Maybe.Nothing.value));+};+var alternativeMaybeT = function (dictMonad) {+ return new Control_Alternative.Alternative(function () {+ return applicativeMaybeT(dictMonad);+ }, function () {+ return plusMaybeT(dictMonad);+ });+};+var monadZeroMaybeT = function (dictMonad) {+ return new Control_MonadZero.MonadZero(function () {+ return alternativeMaybeT(dictMonad);+ }, function () {+ return monadMaybeT(dictMonad);+ });+};+var monadPlusMaybeT = function (dictMonad) {+ return new Control_MonadPlus.MonadPlus(function () {+ return monadZeroMaybeT(dictMonad);+ });+};+module.exports = {+ MaybeT: MaybeT, + mapMaybeT: mapMaybeT, + runMaybeT: runMaybeT, + newtypeMaybeT: newtypeMaybeT, + functorMaybeT: functorMaybeT, + applyMaybeT: applyMaybeT, + applicativeMaybeT: applicativeMaybeT, + bindMaybeT: bindMaybeT, + monadMaybeT: monadMaybeT, + monadTransMaybeT: monadTransMaybeT, + altMaybeT: altMaybeT, + plusMaybeT: plusMaybeT, + alternativeMaybeT: alternativeMaybeT, + monadPlusMaybeT: monadPlusMaybeT, + monadZeroMaybeT: monadZeroMaybeT, + monadRecMaybeT: monadRecMaybeT, + monadEffMaybe: monadEffMaybe, + monadContMaybeT: monadContMaybeT, + monadThrowMaybeT: monadThrowMaybeT, + monadErrorMaybeT: monadErrorMaybeT, + monadAskMaybeT: monadAskMaybeT, + monadReaderMaybeT: monadReaderMaybeT, + monadStateMaybeT: monadStateMaybeT, + monadTellMaybeT: monadTellMaybeT, + monadWriterMaybeT: monadWriterMaybeT+};++},{"../Control.Alt":38,"../Control.Alternative":39,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Category":47,"../Control.Monad":86,"../Control.Monad.Cont.Class":56,"../Control.Monad.Eff.Class":58,"../Control.Monad.Error.Class":71,"../Control.Monad.Reader.Class":75,"../Control.Monad.Rec.Class":77,"../Control.Monad.State.Class":80,"../Control.Monad.Trans.Class":83,"../Control.Monad.Writer.Class":84,"../Control.MonadPlus":87,"../Control.MonadZero":88,"../Control.Plus":91,"../Control.Semigroupoid":92,"../Data.Function":149,"../Data.Functor":155,"../Data.Maybe":198,"../Data.Newtype":209,"../Data.Tuple":245,"../Prelude":268}],75:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var Control_Monad = require("../Control.Monad");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Functor = require("../Data.Functor");+var Prelude = require("../Prelude");+var MonadAsk = function (Monad0, ask) {+ this.Monad0 = Monad0;+ this.ask = ask;+};+var MonadReader = function (MonadAsk0, local) {+ this.MonadAsk0 = MonadAsk0;+ this.local = local;+};+var monadAskFun = new MonadAsk(function () {+ return Control_Monad.monadFn;+}, Control_Category.id(Control_Category.categoryFn));+var monadReaderFun = new MonadReader(function () {+ return monadAskFun;+}, Control_Semigroupoid.composeFlipped(Control_Semigroupoid.semigroupoidFn));+var local = function (dict) {+ return dict.local;+};+var ask = function (dict) {+ return dict.ask;+};+var asks = function (dictMonadAsk) {+ return function (f) {+ return Data_Functor.map((((dictMonadAsk.Monad0()).Bind1()).Apply0()).Functor0())(f)(ask(dictMonadAsk));+ };+};+module.exports = {+ MonadAsk: MonadAsk, + MonadReader: MonadReader, + ask: ask, + asks: asks, + local: local, + monadAskFun: monadAskFun, + monadReaderFun: monadReaderFun+};++},{"../Control.Category":47,"../Control.Monad":86,"../Control.Semigroupoid":92,"../Data.Functor":155,"../Prelude":268}],76:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Control_Alternative = require("../Control.Alternative");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Monad = require("../Control.Monad");+var Control_Monad_Cont_Class = require("../Control.Monad.Cont.Class");+var Control_Monad_Eff_Class = require("../Control.Monad.Eff.Class");+var Control_Monad_Error_Class = require("../Control.Monad.Error.Class");+var Control_Monad_Reader_Class = require("../Control.Monad.Reader.Class");+var Control_Monad_Rec_Class = require("../Control.Monad.Rec.Class");+var Control_Monad_State_Class = require("../Control.Monad.State.Class");+var Control_Monad_Trans_Class = require("../Control.Monad.Trans.Class");+var Control_Monad_Writer_Class = require("../Control.Monad.Writer.Class");+var Control_MonadPlus = require("../Control.MonadPlus");+var Control_MonadZero = require("../Control.MonadZero");+var Control_Plus = require("../Control.Plus");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Distributive = require("../Data.Distributive");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Newtype = require("../Data.Newtype");+var Prelude = require("../Prelude");+var ReaderT = function (x) {+ return x;+};+var withReaderT = function (f) {+ return function (v) {+ return function ($62) {+ return v(f($62));+ };+ };+};+var runReaderT = function (v) {+ return v;+};+var newtypeReaderT = new Data_Newtype.Newtype(function (n) {+ return n;+}, ReaderT);+var monadTransReaderT = new Control_Monad_Trans_Class.MonadTrans(function (dictMonad) {+ return function ($63) {+ return ReaderT(Data_Function["const"]($63));+ };+});+var mapReaderT = function (f) {+ return function (v) {+ return function ($64) {+ return f(v($64));+ };+ };+};+var functorReaderT = function (dictFunctor) {+ return new Data_Functor.Functor(function ($65) {+ return mapReaderT(Data_Functor.map(dictFunctor)($65));+ });+};+var distributiveReaderT = function (dictDistributive) {+ return new Data_Distributive.Distributive(function () {+ return functorReaderT(dictDistributive.Functor0());+ }, function (dictFunctor) {+ return function (f) {+ return function ($66) {+ return Data_Distributive.distribute(distributiveReaderT(dictDistributive))(dictFunctor)(Data_Functor.map(dictFunctor)(f)($66));+ };+ };+ }, function (dictFunctor) {+ return function (a) {+ return function (e) {+ return Data_Distributive.collect(dictDistributive)(dictFunctor)(function (r) {+ return r(e);+ })(a);+ };+ };+ });+};+var applyReaderT = function (dictApply) {+ return new Control_Apply.Apply(function () {+ return functorReaderT(dictApply.Functor0());+ }, function (v) {+ return function (v1) {+ return function (r) {+ return Control_Apply.apply(dictApply)(v(r))(v1(r));+ };+ };+ });+};+var bindReaderT = function (dictBind) {+ return new Control_Bind.Bind(function () {+ return applyReaderT(dictBind.Apply0());+ }, function (v) {+ return function (k) {+ return function (r) {+ return Control_Bind.bind(dictBind)(v(r))(function (a) {+ var v1 = k(a);+ return v1(r);+ });+ };+ };+ });+};+var applicativeReaderT = function (dictApplicative) {+ return new Control_Applicative.Applicative(function () {+ return applyReaderT(dictApplicative.Apply0());+ }, function ($67) {+ return ReaderT(Data_Function["const"](Control_Applicative.pure(dictApplicative)($67)));+ });+};+var monadReaderT = function (dictMonad) {+ return new Control_Monad.Monad(function () {+ return applicativeReaderT(dictMonad.Applicative0());+ }, function () {+ return bindReaderT(dictMonad.Bind1());+ });+};+var monadAskReaderT = function (dictMonad) {+ return new Control_Monad_Reader_Class.MonadAsk(function () {+ return monadReaderT(dictMonad);+ }, Control_Applicative.pure(dictMonad.Applicative0()));+};+var monadReaderReaderT = function (dictMonad) {+ return new Control_Monad_Reader_Class.MonadReader(function () {+ return monadAskReaderT(dictMonad);+ }, withReaderT);+};+var monadContReaderT = function (dictMonadCont) {+ return new Control_Monad_Cont_Class.MonadCont(function () {+ return monadReaderT(dictMonadCont.Monad0());+ }, function (f) {+ return function (r) {+ return Control_Monad_Cont_Class.callCC(dictMonadCont)(function (c) {+ var v = f(function ($68) {+ return ReaderT(Data_Function["const"](c($68)));+ });+ return v(r);+ });+ };+ });+};+var monadEffReader = function (dictMonadEff) {+ return new Control_Monad_Eff_Class.MonadEff(function () {+ return monadReaderT(dictMonadEff.Monad0());+ }, function ($69) {+ return Control_Monad_Trans_Class.lift(monadTransReaderT)(dictMonadEff.Monad0())(Control_Monad_Eff_Class.liftEff(dictMonadEff)($69));+ });+};+var monadRecReaderT = function (dictMonadRec) {+ return new Control_Monad_Rec_Class.MonadRec(function () {+ return monadReaderT(dictMonadRec.Monad0());+ }, function (k) {+ return function (a) {+ var k$prime = function (r) {+ return function (a$prime) {+ var v = k(a$prime);+ return Control_Bind.bindFlipped((dictMonadRec.Monad0()).Bind1())(Control_Applicative.pure((dictMonadRec.Monad0()).Applicative0()))(v(r));+ };+ };+ return function (r) {+ return Control_Monad_Rec_Class.tailRecM(dictMonadRec)(k$prime(r))(a);+ };+ };+ });+};+var monadStateReaderT = function (dictMonadState) {+ return new Control_Monad_State_Class.MonadState(function () {+ return monadReaderT(dictMonadState.Monad0());+ }, function ($70) {+ return Control_Monad_Trans_Class.lift(monadTransReaderT)(dictMonadState.Monad0())(Control_Monad_State_Class.state(dictMonadState)($70));+ });+};+var monadTellReaderT = function (dictMonadTell) {+ return new Control_Monad_Writer_Class.MonadTell(function () {+ return monadReaderT(dictMonadTell.Monad0());+ }, function ($71) {+ return Control_Monad_Trans_Class.lift(monadTransReaderT)(dictMonadTell.Monad0())(Control_Monad_Writer_Class.tell(dictMonadTell)($71));+ });+};+var monadWriterReaderT = function (dictMonadWriter) {+ return new Control_Monad_Writer_Class.MonadWriter(function () {+ return monadTellReaderT(dictMonadWriter.MonadTell0());+ }, mapReaderT(Control_Monad_Writer_Class.listen(dictMonadWriter)), mapReaderT(Control_Monad_Writer_Class.pass(dictMonadWriter)));+};+var monadThrowReaderT = function (dictMonadThrow) {+ return new Control_Monad_Error_Class.MonadThrow(function () {+ return monadReaderT(dictMonadThrow.Monad0());+ }, function ($72) {+ return Control_Monad_Trans_Class.lift(monadTransReaderT)(dictMonadThrow.Monad0())(Control_Monad_Error_Class.throwError(dictMonadThrow)($72));+ });+};+var monadErrorReaderT = function (dictMonadError) {+ return new Control_Monad_Error_Class.MonadError(function () {+ return monadThrowReaderT(dictMonadError.MonadThrow0());+ }, function (v) {+ return function (h) {+ return function (r) {+ return Control_Monad_Error_Class.catchError(dictMonadError)(v(r))(function (e) {+ var v1 = h(e);+ return v1(r);+ });+ };+ };+ });+};+var altReaderT = function (dictAlt) {+ return new Control_Alt.Alt(function () {+ return functorReaderT(dictAlt.Functor0());+ }, function (v) {+ return function (v1) {+ return function (r) {+ return Control_Alt.alt(dictAlt)(v(r))(v1(r));+ };+ };+ });+};+var plusReaderT = function (dictPlus) {+ return new Control_Plus.Plus(function () {+ return altReaderT(dictPlus.Alt0());+ }, Data_Function["const"](Control_Plus.empty(dictPlus)));+};+var alternativeReaderT = function (dictAlternative) {+ return new Control_Alternative.Alternative(function () {+ return applicativeReaderT(dictAlternative.Applicative0());+ }, function () {+ return plusReaderT(dictAlternative.Plus1());+ });+};+var monadZeroReaderT = function (dictMonadZero) {+ return new Control_MonadZero.MonadZero(function () {+ return alternativeReaderT(dictMonadZero.Alternative1());+ }, function () {+ return monadReaderT(dictMonadZero.Monad0());+ });+};+var monadPlusReaderT = function (dictMonadPlus) {+ return new Control_MonadPlus.MonadPlus(function () {+ return monadZeroReaderT(dictMonadPlus.MonadZero0());+ });+};+module.exports = {+ ReaderT: ReaderT, + mapReaderT: mapReaderT, + runReaderT: runReaderT, + withReaderT: withReaderT, + newtypeReaderT: newtypeReaderT, + functorReaderT: functorReaderT, + applyReaderT: applyReaderT, + applicativeReaderT: applicativeReaderT, + altReaderT: altReaderT, + plusReaderT: plusReaderT, + alternativeReaderT: alternativeReaderT, + bindReaderT: bindReaderT, + monadReaderT: monadReaderT, + monadZeroReaderT: monadZeroReaderT, + monadPlusReaderT: monadPlusReaderT, + monadTransReaderT: monadTransReaderT, + monadEffReader: monadEffReader, + monadContReaderT: monadContReaderT, + monadThrowReaderT: monadThrowReaderT, + monadErrorReaderT: monadErrorReaderT, + monadAskReaderT: monadAskReaderT, + monadReaderReaderT: monadReaderReaderT, + monadStateReaderT: monadStateReaderT, + monadTellReaderT: monadTellReaderT, + monadWriterReaderT: monadWriterReaderT, + distributiveReaderT: distributiveReaderT, + monadRecReaderT: monadRecReaderT+};++},{"../Control.Alt":38,"../Control.Alternative":39,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Monad":86,"../Control.Monad.Cont.Class":56,"../Control.Monad.Eff.Class":58,"../Control.Monad.Error.Class":71,"../Control.Monad.Reader.Class":75,"../Control.Monad.Rec.Class":77,"../Control.Monad.State.Class":80,"../Control.Monad.Trans.Class":83,"../Control.Monad.Writer.Class":84,"../Control.MonadPlus":87,"../Control.MonadZero":88,"../Control.Plus":91,"../Control.Semigroupoid":92,"../Data.Distributive":135,"../Data.Function":149,"../Data.Functor":155,"../Data.Newtype":209,"../Prelude":268}],77:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Bind = require("../Control.Bind");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var Control_Monad_Eff_Unsafe = require("../Control.Monad.Eff.Unsafe");+var Control_Monad_ST = require("../Control.Monad.ST");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Bifunctor = require("../Data.Bifunctor");+var Data_Either = require("../Data.Either");+var Data_Functor = require("../Data.Functor");+var Data_Identity = require("../Data.Identity");+var Data_Unit = require("../Data.Unit");+var Partial_Unsafe = require("../Partial.Unsafe");+var Prelude = require("../Prelude");+var Loop = (function () {+ function Loop(value0) {+ this.value0 = value0;+ };+ Loop.create = function (value0) {+ return new Loop(value0);+ };+ return Loop;+})();+var Done = (function () {+ function Done(value0) {+ this.value0 = value0;+ };+ Done.create = function (value0) {+ return new Done(value0);+ };+ return Done;+})();+var MonadRec = function (Monad0, tailRecM) {+ this.Monad0 = Monad0;+ this.tailRecM = tailRecM;+};+var tailRecM = function (dict) {+ return dict.tailRecM;+};+var tailRecM2 = function (dictMonadRec) {+ return function (f) {+ return function (a) {+ return function (b) {+ return tailRecM(dictMonadRec)(function (o) {+ return f(o.a)(o.b);+ })({+ a: a, + b: b+ });+ };+ };+ };+};+var tailRecM3 = function (dictMonadRec) {+ return function (f) {+ return function (a) {+ return function (b) {+ return function (c) {+ return tailRecM(dictMonadRec)(function (o) {+ return f(o.a)(o.b)(o.c);+ })({+ a: a, + b: b, + c: c+ });+ };+ };+ };+ };+};+var tailRecEff = function (f) {+ return function (a) {+ var fromDone = function (v) {+ var __unused = function (dictPartial1) {+ return function ($dollar16) {+ return $dollar16;+ };+ };+ return __unused()((function () {+ if (v instanceof Done) {+ return v.value0;+ };+ throw new Error("Failed pattern match at Control.Monad.Rec.Class line 130, column 28 - line 130, column 42: " + [ v.constructor.name ]);+ })());+ };+ var f$prime = function ($48) {+ return Control_Monad_Eff_Unsafe.unsafeCoerceEff(f($48));+ };+ return function __do() {+ var v = f$prime(a)();+ var v1 = {+ value: v+ };+ (function () {+ while (!(function __do() {+ var v2 = v1.value;+ if (v2 instanceof Loop) {+ var v3 = f$prime(v2.value0)();+ var v4 = v1.value = v3;+ return false;+ };+ if (v2 instanceof Done) {+ return true;+ };+ throw new Error("Failed pattern match at Control.Monad.Rec.Class line 119, column 5 - line 124, column 26: " + [ v2.constructor.name ]);+ })()) {++ };+ return {};+ })();+ return Data_Functor.map(Control_Monad_Eff.functorEff)(fromDone)(Control_Monad_ST.readSTRef(v1))();+ };+ };+};+var tailRec = function (f) {+ var go = function (__copy_v) {+ var v = __copy_v;+ var __tco_done = false;+ var __tco_result;+ var __tco_v;+ function __tco_loop(v) {+ if (v instanceof Loop) {+ __tco_v = f(v.value0);+ return;+ };+ if (v instanceof Done) {+ __tco_done = true;+ return v.value0;+ };+ throw new Error("Failed pattern match at Control.Monad.Rec.Class line 93, column 13 - line 96, column 18: " + [ v.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(v);+ v = __tco_v;+ };+ return __tco_result;+ };+ return function ($49) {+ return go(f($49));+ };+};+var monadRecIdentity = new MonadRec(function () {+ return Data_Identity.monadIdentity;+}, function (f) {+ var runIdentity = function (v) {+ return v;+ };+ return function ($50) {+ return Data_Identity.Identity(tailRec(function ($51) {+ return runIdentity(f($51));+ })($50));+ };+});+var monadRecEither = new MonadRec(function () {+ return Data_Either.monadEither;+}, function (f) {+ return function (a0) {+ var g = function (v) {+ if (v instanceof Data_Either.Left) {+ return new Done(new Data_Either.Left(v.value0));+ };+ if (v instanceof Data_Either.Right && v.value0 instanceof Loop) {+ return new Loop(f(v.value0.value0));+ };+ if (v instanceof Data_Either.Right && v.value0 instanceof Done) {+ return new Done(new Data_Either.Right(v.value0.value0));+ };+ throw new Error("Failed pattern match at Control.Monad.Rec.Class line 108, column 7 - line 108, column 33: " + [ v.constructor.name ]);+ };+ return tailRec(g)(f(a0));+ };+});+var monadRecEff = new MonadRec(function () {+ return Control_Monad_Eff.monadEff;+}, tailRecEff);+var functorStep = new Data_Functor.Functor(function (f) {+ return function (v) {+ if (v instanceof Loop) {+ return new Loop(v.value0);+ };+ if (v instanceof Done) {+ return new Done(f(v.value0));+ };+ throw new Error("Failed pattern match at Control.Monad.Rec.Class line 28, column 3 - line 28, column 26: " + [ f.constructor.name, v.constructor.name ]);+ };+});+var forever = function (dictMonadRec) {+ return function (ma) {+ return tailRecM(dictMonadRec)(function (u) {+ return Data_Functor.voidRight((((dictMonadRec.Monad0()).Bind1()).Apply0()).Functor0())(new Loop(u))(ma);+ })(Data_Unit.unit);+ };+};+var bifunctorStep = new Data_Bifunctor.Bifunctor(function (v) {+ return function (v1) {+ return function (v2) {+ if (v2 instanceof Loop) {+ return new Loop(v(v2.value0));+ };+ if (v2 instanceof Done) {+ return new Done(v1(v2.value0));+ };+ throw new Error("Failed pattern match at Control.Monad.Rec.Class line 32, column 3 - line 32, column 34: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);+ };+ };+});+module.exports = {+ Loop: Loop, + Done: Done, + MonadRec: MonadRec, + forever: forever, + tailRec: tailRec, + tailRecM: tailRecM, + tailRecM2: tailRecM2, + tailRecM3: tailRecM3, + functorStep: functorStep, + bifunctorStep: bifunctorStep, + monadRecIdentity: monadRecIdentity, + monadRecEff: monadRecEff, + monadRecEither: monadRecEither+};++},{"../Control.Applicative":40,"../Control.Bind":46,"../Control.Monad.Eff":70,"../Control.Monad.Eff.Unsafe":68,"../Control.Monad.ST":79,"../Control.Semigroupoid":92,"../Data.Bifunctor":127,"../Data.Either":136,"../Data.Functor":155,"../Data.Identity":161,"../Data.Unit":249,"../Partial.Unsafe":265,"../Prelude":268}],78:[function(require,module,exports){+"use strict";++exports.newSTRef = function (val) {+ return function () {+ return { value: val };+ };+};++exports.readSTRef = function (ref) {+ return function () {+ return ref.value;+ };+};++exports.modifySTRef = function (ref) {+ return function (f) {+ return function () {+ return ref.value = f(ref.value); // eslint-disable-line no-return-assign+ };+ };+};++exports.writeSTRef = function (ref) {+ return function (a) {+ return function () {+ return ref.value = a; // eslint-disable-line no-return-assign+ };+ };+};++exports.runST = function (f) {+ return f;+};++},{}],79:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var pureST = function (st) {+ return Control_Monad_Eff.runPure($foreign.runST(st));+};+module.exports = {+ pureST: pureST, + modifySTRef: $foreign.modifySTRef, + newSTRef: $foreign.newSTRef, + readSTRef: $foreign.readSTRef, + runST: $foreign.runST, + writeSTRef: $foreign.writeSTRef+};++},{"../Control.Monad.Eff":70,"./foreign":78}],80:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Tuple = require("../Data.Tuple");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var MonadState = function (Monad0, state) {+ this.Monad0 = Monad0;+ this.state = state;+};+var state = function (dict) {+ return dict.state;+};+var put = function (dictMonadState) {+ return function (s) {+ return state(dictMonadState)(function (v) {+ return new Data_Tuple.Tuple(Data_Unit.unit, s);+ });+ };+};+var modify = function (dictMonadState) {+ return function (f) {+ return state(dictMonadState)(function (s) {+ return new Data_Tuple.Tuple(Data_Unit.unit, f(s));+ });+ };+};+var gets = function (dictMonadState) {+ return function (f) {+ return state(dictMonadState)(function (s) {+ return new Data_Tuple.Tuple(f(s), s);+ });+ };+};+var get = function (dictMonadState) {+ return state(dictMonadState)(function (s) {+ return new Data_Tuple.Tuple(s, s);+ });+};+module.exports = {+ MonadState: MonadState, + get: get, + gets: gets, + modify: modify, + put: put, + state: state+};++},{"../Data.Tuple":245,"../Data.Unit":249,"../Prelude":268}],81:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Control_Alternative = require("../Control.Alternative");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Lazy = require("../Control.Lazy");+var Control_Monad = require("../Control.Monad");+var Control_Monad_Cont_Class = require("../Control.Monad.Cont.Class");+var Control_Monad_Eff_Class = require("../Control.Monad.Eff.Class");+var Control_Monad_Error_Class = require("../Control.Monad.Error.Class");+var Control_Monad_Reader_Class = require("../Control.Monad.Reader.Class");+var Control_Monad_Rec_Class = require("../Control.Monad.Rec.Class");+var Control_Monad_State_Class = require("../Control.Monad.State.Class");+var Control_Monad_Trans_Class = require("../Control.Monad.Trans.Class");+var Control_Monad_Writer_Class = require("../Control.Monad.Writer.Class");+var Control_MonadPlus = require("../Control.MonadPlus");+var Control_MonadZero = require("../Control.MonadZero");+var Control_Plus = require("../Control.Plus");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Newtype = require("../Data.Newtype");+var Data_Tuple = require("../Data.Tuple");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var StateT = function (x) {+ return x;+};+var withStateT = function (f) {+ return function (v) {+ return function ($107) {+ return v(f($107));+ };+ };+};+var runStateT = function (v) {+ return v;+};+var newtypeStateT = new Data_Newtype.Newtype(function (n) {+ return n;+}, StateT);+var monadTransStateT = new Control_Monad_Trans_Class.MonadTrans(function (dictMonad) {+ return function (m) {+ return function (s) {+ return Control_Bind.bind(dictMonad.Bind1())(m)(function (v) {+ return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Tuple.Tuple(v, s));+ });+ };+ };+});+var mapStateT = function (f) {+ return function (v) {+ return function ($108) {+ return f(v($108));+ };+ };+};+var lazyStateT = new Control_Lazy.Lazy(function (f) {+ return function (s) {+ var v = f(Data_Unit.unit);+ return v(s);+ };+});+var functorStateT = function (dictFunctor) {+ return new Data_Functor.Functor(function (f) {+ return function (v) {+ return function (s) {+ return Data_Functor.map(dictFunctor)(function (v1) {+ return new Data_Tuple.Tuple(f(v1.value0), v1.value1);+ })(v(s));+ };+ };+ });+};+var execStateT = function (dictFunctor) {+ return function (v) {+ return function (s) {+ return Data_Functor.map(dictFunctor)(Data_Tuple.snd)(v(s));+ };+ };+};+var evalStateT = function (dictFunctor) {+ return function (v) {+ return function (s) {+ return Data_Functor.map(dictFunctor)(Data_Tuple.fst)(v(s));+ };+ };+};+var monadStateT = function (dictMonad) {+ return new Control_Monad.Monad(function () {+ return applicativeStateT(dictMonad);+ }, function () {+ return bindStateT(dictMonad);+ });+};+var bindStateT = function (dictMonad) {+ return new Control_Bind.Bind(function () {+ return applyStateT(dictMonad);+ }, function (v) {+ return function (f) {+ return function (s) {+ return Control_Bind.bind(dictMonad.Bind1())(v(s))(function (v1) {+ var v3 = f(v1.value0);+ return v3(v1.value1);+ });+ };+ };+ });+};+var applyStateT = function (dictMonad) {+ return new Control_Apply.Apply(function () {+ return functorStateT(((dictMonad.Bind1()).Apply0()).Functor0());+ }, Control_Monad.ap(monadStateT(dictMonad)));+};+var applicativeStateT = function (dictMonad) {+ return new Control_Applicative.Applicative(function () {+ return applyStateT(dictMonad);+ }, function (a) {+ return function (s) {+ return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Tuple.Tuple(a, s));+ };+ });+};+var monadAskStateT = function (dictMonadAsk) {+ return new Control_Monad_Reader_Class.MonadAsk(function () {+ return monadStateT(dictMonadAsk.Monad0());+ }, Control_Monad_Trans_Class.lift(monadTransStateT)(dictMonadAsk.Monad0())(Control_Monad_Reader_Class.ask(dictMonadAsk)));+};+var monadReaderStateT = function (dictMonadReader) {+ return new Control_Monad_Reader_Class.MonadReader(function () {+ return monadAskStateT(dictMonadReader.MonadAsk0());+ }, function ($109) {+ return mapStateT(Control_Monad_Reader_Class.local(dictMonadReader)($109));+ });+};+var monadContStateT = function (dictMonadCont) {+ return new Control_Monad_Cont_Class.MonadCont(function () {+ return monadStateT(dictMonadCont.Monad0());+ }, function (f) {+ return function (s) {+ return Control_Monad_Cont_Class.callCC(dictMonadCont)(function (c) {+ var v = f(function (a) {+ return function (s$prime) {+ return c(new Data_Tuple.Tuple(a, s$prime));+ };+ });+ return v(s);+ });+ };+ });+};+var monadEffState = function (dictMonadEff) {+ return new Control_Monad_Eff_Class.MonadEff(function () {+ return monadStateT(dictMonadEff.Monad0());+ }, function ($110) {+ return Control_Monad_Trans_Class.lift(monadTransStateT)(dictMonadEff.Monad0())(Control_Monad_Eff_Class.liftEff(dictMonadEff)($110));+ });+};+var monadRecStateT = function (dictMonadRec) {+ return new Control_Monad_Rec_Class.MonadRec(function () {+ return monadStateT(dictMonadRec.Monad0());+ }, function (f) {+ return function (a) {+ var f$prime = function (v) {+ return Control_Bind.bind((dictMonadRec.Monad0()).Bind1())((function () {+ var v1 = f(v.value0);+ return v1;+ })()(v.value1))(function (v1) {+ return Control_Applicative.pure((dictMonadRec.Monad0()).Applicative0())((function () {+ if (v1.value0 instanceof Control_Monad_Rec_Class.Loop) {+ return new Control_Monad_Rec_Class.Loop(new Data_Tuple.Tuple(v1.value0.value0, v1.value1));+ };+ if (v1.value0 instanceof Control_Monad_Rec_Class.Done) {+ return new Control_Monad_Rec_Class.Done(new Data_Tuple.Tuple(v1.value0.value0, v1.value1));+ };+ throw new Error("Failed pattern match at Control.Monad.State.Trans line 88, column 16 - line 90, column 40: " + [ v1.value0.constructor.name ]);+ })());+ });+ };+ return function (s) {+ return Control_Monad_Rec_Class.tailRecM(dictMonadRec)(f$prime)(new Data_Tuple.Tuple(a, s));+ };+ };+ });+};+var monadStateStateT = function (dictMonad) {+ return new Control_Monad_State_Class.MonadState(function () {+ return monadStateT(dictMonad);+ }, function (f) {+ return StateT(function ($111) {+ return Control_Applicative.pure(dictMonad.Applicative0())(f($111));+ });+ });+};+var monadTellStateT = function (dictMonadTell) {+ return new Control_Monad_Writer_Class.MonadTell(function () {+ return monadStateT(dictMonadTell.Monad0());+ }, function ($112) {+ return Control_Monad_Trans_Class.lift(monadTransStateT)(dictMonadTell.Monad0())(Control_Monad_Writer_Class.tell(dictMonadTell)($112));+ });+};+var monadWriterStateT = function (dictMonadWriter) {+ return new Control_Monad_Writer_Class.MonadWriter(function () {+ return monadTellStateT(dictMonadWriter.MonadTell0());+ }, function (m) {+ return function (s) {+ return Control_Bind.bind(((dictMonadWriter.MonadTell0()).Monad0()).Bind1())(Control_Monad_Writer_Class.listen(dictMonadWriter)(m(s)))(function (v) {+ return Control_Applicative.pure(((dictMonadWriter.MonadTell0()).Monad0()).Applicative0())(new Data_Tuple.Tuple(new Data_Tuple.Tuple(v.value0.value0, v.value1), v.value0.value1));+ });+ };+ }, function (m) {+ return function (s) {+ return Control_Monad_Writer_Class.pass(dictMonadWriter)(Control_Bind.bind(((dictMonadWriter.MonadTell0()).Monad0()).Bind1())(m(s))(function (v) {+ return Control_Applicative.pure(((dictMonadWriter.MonadTell0()).Monad0()).Applicative0())(new Data_Tuple.Tuple(new Data_Tuple.Tuple(v.value0.value0, v.value1), v.value0.value1));+ }));+ };+ });+};+var monadThrowStateT = function (dictMonadThrow) {+ return new Control_Monad_Error_Class.MonadThrow(function () {+ return monadStateT(dictMonadThrow.Monad0());+ }, function (e) {+ return Control_Monad_Trans_Class.lift(monadTransStateT)(dictMonadThrow.Monad0())(Control_Monad_Error_Class.throwError(dictMonadThrow)(e));+ });+};+var monadErrorStateT = function (dictMonadError) {+ return new Control_Monad_Error_Class.MonadError(function () {+ return monadThrowStateT(dictMonadError.MonadThrow0());+ }, function (v) {+ return function (h) {+ return function (s) {+ return Control_Monad_Error_Class.catchError(dictMonadError)(v(s))(function (e) {+ var v1 = h(e);+ return v1(s);+ });+ };+ };+ });+};+var altStateT = function (dictMonad) {+ return function (dictAlt) {+ return new Control_Alt.Alt(function () {+ return functorStateT(dictAlt.Functor0());+ }, function (v) {+ return function (v1) {+ return function (s) {+ return Control_Alt.alt(dictAlt)(v(s))(v1(s));+ };+ };+ });+ };+};+var plusStateT = function (dictMonad) {+ return function (dictPlus) {+ return new Control_Plus.Plus(function () {+ return altStateT(dictMonad)(dictPlus.Alt0());+ }, function (v) {+ return Control_Plus.empty(dictPlus);+ });+ };+};+var alternativeStateT = function (dictMonad) {+ return function (dictAlternative) {+ return new Control_Alternative.Alternative(function () {+ return applicativeStateT(dictMonad);+ }, function () {+ return plusStateT(dictMonad)(dictAlternative.Plus1());+ });+ };+};+var monadZeroStateT = function (dictMonadZero) {+ return new Control_MonadZero.MonadZero(function () {+ return alternativeStateT(dictMonadZero.Monad0())(dictMonadZero.Alternative1());+ }, function () {+ return monadStateT(dictMonadZero.Monad0());+ });+};+var monadPlusStateT = function (dictMonadPlus) {+ return new Control_MonadPlus.MonadPlus(function () {+ return monadZeroStateT(dictMonadPlus.MonadZero0());+ });+};+module.exports = {+ StateT: StateT, + evalStateT: evalStateT, + execStateT: execStateT, + mapStateT: mapStateT, + runStateT: runStateT, + withStateT: withStateT, + newtypeStateT: newtypeStateT, + functorStateT: functorStateT, + applyStateT: applyStateT, + applicativeStateT: applicativeStateT, + altStateT: altStateT, + plusStateT: plusStateT, + alternativeStateT: alternativeStateT, + bindStateT: bindStateT, + monadStateT: monadStateT, + monadRecStateT: monadRecStateT, + monadZeroStateT: monadZeroStateT, + monadPlusStateT: monadPlusStateT, + monadTransStateT: monadTransStateT, + lazyStateT: lazyStateT, + monadEffState: monadEffState, + monadContStateT: monadContStateT, + monadThrowStateT: monadThrowStateT, + monadErrorStateT: monadErrorStateT, + monadAskStateT: monadAskStateT, + monadReaderStateT: monadReaderStateT, + monadStateStateT: monadStateStateT, + monadTellStateT: monadTellStateT, + monadWriterStateT: monadWriterStateT+};++},{"../Control.Alt":38,"../Control.Alternative":39,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Lazy":50,"../Control.Monad":86,"../Control.Monad.Cont.Class":56,"../Control.Monad.Eff.Class":58,"../Control.Monad.Error.Class":71,"../Control.Monad.Reader.Class":75,"../Control.Monad.Rec.Class":77,"../Control.Monad.State.Class":80,"../Control.Monad.Trans.Class":83,"../Control.Monad.Writer.Class":84,"../Control.MonadPlus":87,"../Control.MonadZero":88,"../Control.Plus":91,"../Control.Semigroupoid":92,"../Data.Function":149,"../Data.Functor":155,"../Data.Newtype":209,"../Data.Tuple":245,"../Data.Unit":249,"../Prelude":268}],82:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Monad_State_Class = require("../Control.Monad.State.Class");+var Control_Monad_State_Trans = require("../Control.Monad.State.Trans");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Identity = require("../Data.Identity");+var Data_Newtype = require("../Data.Newtype");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var withState = Control_Monad_State_Trans.withStateT;+var runState = function (v) {+ return function ($16) {+ return Data_Newtype.unwrap(Data_Identity.newtypeIdentity)(v($16));+ };+};+var mapState = function (f) {+ return Control_Monad_State_Trans.mapStateT(function ($17) {+ return Data_Identity.Identity(f(Data_Newtype.unwrap(Data_Identity.newtypeIdentity)($17)));+ });+};+var execState = function (v) {+ return function (s) {+ var v1 = v(s);+ return v1.value1;+ };+};+var evalState = function (v) {+ return function (s) {+ var v1 = v(s);+ return v1.value0;+ };+};+module.exports = {+ evalState: evalState, + execState: execState, + mapState: mapState, + runState: runState, + withState: withState+};++},{"../Control.Monad.State.Class":80,"../Control.Monad.State.Trans":81,"../Control.Semigroupoid":92,"../Data.Identity":161,"../Data.Newtype":209,"../Data.Tuple":245,"../Prelude":268}],83:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Prelude = require("../Prelude");+var MonadTrans = function (lift) {+ this.lift = lift;+};+var lift = function (dict) {+ return dict.lift;+};+module.exports = {+ MonadTrans: MonadTrans, + lift: lift+};++},{"../Prelude":268}],84:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Bind = require("../Control.Bind");+var Data_Function = require("../Data.Function");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var MonadTell = function (Monad0, tell) {+ this.Monad0 = Monad0;+ this.tell = tell;+};+var MonadWriter = function (MonadTell0, listen, pass) {+ this.MonadTell0 = MonadTell0;+ this.listen = listen;+ this.pass = pass;+};+var tell = function (dict) {+ return dict.tell;+};+var pass = function (dict) {+ return dict.pass;+};+var listen = function (dict) {+ return dict.listen;+};+var listens = function (dictMonadWriter) {+ return function (f) {+ return function (m) {+ return Control_Bind.bind(((dictMonadWriter.MonadTell0()).Monad0()).Bind1())(listen(dictMonadWriter)(m))(function (v) {+ return Control_Applicative.pure(((dictMonadWriter.MonadTell0()).Monad0()).Applicative0())(new Data_Tuple.Tuple(v.value0, f(v.value1)));+ });+ };+ };+};+var censor = function (dictMonadWriter) {+ return function (f) {+ return function (m) {+ return pass(dictMonadWriter)(Control_Bind.bind(((dictMonadWriter.MonadTell0()).Monad0()).Bind1())(m)(function (v) {+ return Control_Applicative.pure(((dictMonadWriter.MonadTell0()).Monad0()).Applicative0())(new Data_Tuple.Tuple(v, f));+ }));+ };+ };+};+module.exports = {+ MonadTell: MonadTell, + MonadWriter: MonadWriter, + censor: censor, + listen: listen, + listens: listens, + pass: pass, + tell: tell+};++},{"../Control.Applicative":40,"../Control.Bind":46,"../Data.Function":149,"../Data.Tuple":245,"../Prelude":268}],85:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Control_Alternative = require("../Control.Alternative");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Monad = require("../Control.Monad");+var Control_Monad_Cont_Class = require("../Control.Monad.Cont.Class");+var Control_Monad_Eff_Class = require("../Control.Monad.Eff.Class");+var Control_Monad_Error_Class = require("../Control.Monad.Error.Class");+var Control_Monad_Reader_Class = require("../Control.Monad.Reader.Class");+var Control_Monad_Rec_Class = require("../Control.Monad.Rec.Class");+var Control_Monad_State_Class = require("../Control.Monad.State.Class");+var Control_Monad_Trans_Class = require("../Control.Monad.Trans.Class");+var Control_Monad_Writer_Class = require("../Control.Monad.Writer.Class");+var Control_MonadPlus = require("../Control.MonadPlus");+var Control_MonadZero = require("../Control.MonadZero");+var Control_Plus = require("../Control.Plus");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Monoid = require("../Data.Monoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Tuple = require("../Data.Tuple");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var WriterT = function (x) {+ return x;+};+var runWriterT = function (v) {+ return v;+};+var newtypeWriterT = new Data_Newtype.Newtype(function (n) {+ return n;+}, WriterT);+var monadTransWriterT = function (dictMonoid) {+ return new Control_Monad_Trans_Class.MonadTrans(function (dictMonad) {+ return function (m) {+ return Control_Bind.bind(dictMonad.Bind1())(m)(function (v) {+ return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Tuple.Tuple(v, Data_Monoid.mempty(dictMonoid)));+ });+ };+ });+};+var mapWriterT = function (f) {+ return function (v) {+ return f(v);+ };+};+var functorWriterT = function (dictFunctor) {+ return new Data_Functor.Functor(function (f) {+ return mapWriterT(Data_Functor.map(dictFunctor)(function (v) {+ return new Data_Tuple.Tuple(f(v.value0), v.value1);+ }));+ });+};+var execWriterT = function (dictFunctor) {+ return function (v) {+ return Data_Functor.map(dictFunctor)(Data_Tuple.snd)(v);+ };+};+var applyWriterT = function (dictSemigroup) {+ return function (dictApply) {+ return new Control_Apply.Apply(function () {+ return functorWriterT(dictApply.Functor0());+ }, function (v) {+ return function (v1) {+ var k = function (v3) {+ return function (v4) {+ return new Data_Tuple.Tuple(v3.value0(v4.value0), Data_Semigroup.append(dictSemigroup)(v3.value1)(v4.value1));+ };+ };+ return Control_Apply.apply(dictApply)(Data_Functor.map(dictApply.Functor0())(k)(v))(v1);+ };+ });+ };+};+var bindWriterT = function (dictSemigroup) {+ return function (dictBind) {+ return new Control_Bind.Bind(function () {+ return applyWriterT(dictSemigroup)(dictBind.Apply0());+ }, function (v) {+ return function (k) {+ return WriterT(Control_Bind.bind(dictBind)(v)(function (v1) {+ var v2 = k(v1.value0);+ return Data_Functor.map((dictBind.Apply0()).Functor0())(function (v3) {+ return new Data_Tuple.Tuple(v3.value0, Data_Semigroup.append(dictSemigroup)(v1.value1)(v3.value1));+ })(v2);+ }));+ };+ });+ };+};+var applicativeWriterT = function (dictMonoid) {+ return function (dictApplicative) {+ return new Control_Applicative.Applicative(function () {+ return applyWriterT(dictMonoid.Semigroup0())(dictApplicative.Apply0());+ }, function (a) {+ return WriterT(Control_Applicative.pure(dictApplicative)(new Data_Tuple.Tuple(a, Data_Monoid.mempty(dictMonoid))));+ });+ };+};+var monadWriterT = function (dictMonoid) {+ return function (dictMonad) {+ return new Control_Monad.Monad(function () {+ return applicativeWriterT(dictMonoid)(dictMonad.Applicative0());+ }, function () {+ return bindWriterT(dictMonoid.Semigroup0())(dictMonad.Bind1());+ });+ };+};+var monadAskWriterT = function (dictMonoid) {+ return function (dictMonadAsk) {+ return new Control_Monad_Reader_Class.MonadAsk(function () {+ return monadWriterT(dictMonoid)(dictMonadAsk.Monad0());+ }, Control_Monad_Trans_Class.lift(monadTransWriterT(dictMonoid))(dictMonadAsk.Monad0())(Control_Monad_Reader_Class.ask(dictMonadAsk)));+ };+};+var monadReaderWriterT = function (dictMonoid) {+ return function (dictMonadReader) {+ return new Control_Monad_Reader_Class.MonadReader(function () {+ return monadAskWriterT(dictMonoid)(dictMonadReader.MonadAsk0());+ }, function (f) {+ return mapWriterT(Control_Monad_Reader_Class.local(dictMonadReader)(f));+ });+ };+};+var monadContWriterT = function (dictMonoid) {+ return function (dictMonadCont) {+ return new Control_Monad_Cont_Class.MonadCont(function () {+ return monadWriterT(dictMonoid)(dictMonadCont.Monad0());+ }, function (f) {+ return WriterT(Control_Monad_Cont_Class.callCC(dictMonadCont)(function (c) {+ var v = f(function (a) {+ return WriterT(c(new Data_Tuple.Tuple(a, Data_Monoid.mempty(dictMonoid))));+ });+ return v;+ }));+ });+ };+};+var monadEffWriter = function (dictMonoid) {+ return function (dictMonadEff) {+ return new Control_Monad_Eff_Class.MonadEff(function () {+ return monadWriterT(dictMonoid)(dictMonadEff.Monad0());+ }, function ($123) {+ return Control_Monad_Trans_Class.lift(monadTransWriterT(dictMonoid))(dictMonadEff.Monad0())(Control_Monad_Eff_Class.liftEff(dictMonadEff)($123));+ });+ };+};+var monadRecWriterT = function (dictMonoid) {+ return function (dictMonadRec) {+ return new Control_Monad_Rec_Class.MonadRec(function () {+ return monadWriterT(dictMonoid)(dictMonadRec.Monad0());+ }, function (f) {+ return function (a) {+ var f$prime = function (v) {+ return Control_Bind.bind((dictMonadRec.Monad0()).Bind1())((function () {+ var v1 = f(v.value0);+ return v1;+ })())(function (v1) {+ return Control_Applicative.pure((dictMonadRec.Monad0()).Applicative0())((function () {+ if (v1.value0 instanceof Control_Monad_Rec_Class.Loop) {+ return new Control_Monad_Rec_Class.Loop(new Data_Tuple.Tuple(v1.value0.value0, Data_Semigroup.append(dictMonoid.Semigroup0())(v.value1)(v1.value1)));+ };+ if (v1.value0 instanceof Control_Monad_Rec_Class.Done) {+ return new Control_Monad_Rec_Class.Done(new Data_Tuple.Tuple(v1.value0.value0, Data_Semigroup.append(dictMonoid.Semigroup0())(v.value1)(v1.value1)));+ };+ throw new Error("Failed pattern match at Control.Monad.Writer.Trans line 85, column 16 - line 87, column 47: " + [ v1.value0.constructor.name ]);+ })());+ });+ };+ return WriterT(Control_Monad_Rec_Class.tailRecM(dictMonadRec)(f$prime)(new Data_Tuple.Tuple(a, Data_Monoid.mempty(dictMonoid))));+ };+ });+ };+};+var monadStateWriterT = function (dictMonoid) {+ return function (dictMonadState) {+ return new Control_Monad_State_Class.MonadState(function () {+ return monadWriterT(dictMonoid)(dictMonadState.Monad0());+ }, function (f) {+ return Control_Monad_Trans_Class.lift(monadTransWriterT(dictMonoid))(dictMonadState.Monad0())(Control_Monad_State_Class.state(dictMonadState)(f));+ });+ };+};+var monadTellWriterT = function (dictMonoid) {+ return function (dictMonad) {+ return new Control_Monad_Writer_Class.MonadTell(function () {+ return monadWriterT(dictMonoid)(dictMonad);+ }, function ($124) {+ return WriterT(Control_Applicative.pure(dictMonad.Applicative0())(Data_Tuple.Tuple.create(Data_Unit.unit)($124)));+ });+ };+};+var monadWriterWriterT = function (dictMonoid) {+ return function (dictMonad) {+ return new Control_Monad_Writer_Class.MonadWriter(function () {+ return monadTellWriterT(dictMonoid)(dictMonad);+ }, function (v) {+ return Control_Bind.bind(dictMonad.Bind1())(v)(function (v1) {+ return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Tuple.Tuple(new Data_Tuple.Tuple(v1.value0, v1.value1), v1.value1));+ });+ }, function (v) {+ return Control_Bind.bind(dictMonad.Bind1())(v)(function (v1) {+ return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Tuple.Tuple(v1.value0.value0, v1.value0.value1(v1.value1)));+ });+ });+ };+};+var monadThrowWriterT = function (dictMonoid) {+ return function (dictMonadThrow) {+ return new Control_Monad_Error_Class.MonadThrow(function () {+ return monadWriterT(dictMonoid)(dictMonadThrow.Monad0());+ }, function (e) {+ return Control_Monad_Trans_Class.lift(monadTransWriterT(dictMonoid))(dictMonadThrow.Monad0())(Control_Monad_Error_Class.throwError(dictMonadThrow)(e));+ });+ };+};+var monadErrorWriterT = function (dictMonoid) {+ return function (dictMonadError) {+ return new Control_Monad_Error_Class.MonadError(function () {+ return monadThrowWriterT(dictMonoid)(dictMonadError.MonadThrow0());+ }, function (v) {+ return function (h) {+ return WriterT(Control_Monad_Error_Class.catchError(dictMonadError)(v)(function (e) {+ var v1 = h(e);+ return v1;+ }));+ };+ });+ };+};+var altWriterT = function (dictAlt) {+ return new Control_Alt.Alt(function () {+ return functorWriterT(dictAlt.Functor0());+ }, function (v) {+ return function (v1) {+ return Control_Alt.alt(dictAlt)(v)(v1);+ };+ });+};+var plusWriterT = function (dictPlus) {+ return new Control_Plus.Plus(function () {+ return altWriterT(dictPlus.Alt0());+ }, Control_Plus.empty(dictPlus));+};+var alternativeWriterT = function (dictMonoid) {+ return function (dictAlternative) {+ return new Control_Alternative.Alternative(function () {+ return applicativeWriterT(dictMonoid)(dictAlternative.Applicative0());+ }, function () {+ return plusWriterT(dictAlternative.Plus1());+ });+ };+};+var monadZeroWriterT = function (dictMonoid) {+ return function (dictMonadZero) {+ return new Control_MonadZero.MonadZero(function () {+ return alternativeWriterT(dictMonoid)(dictMonadZero.Alternative1());+ }, function () {+ return monadWriterT(dictMonoid)(dictMonadZero.Monad0());+ });+ };+};+var monadPlusWriterT = function (dictMonoid) {+ return function (dictMonadPlus) {+ return new Control_MonadPlus.MonadPlus(function () {+ return monadZeroWriterT(dictMonoid)(dictMonadPlus.MonadZero0());+ });+ };+};+module.exports = {+ WriterT: WriterT, + execWriterT: execWriterT, + mapWriterT: mapWriterT, + runWriterT: runWriterT, + newtypeWriterT: newtypeWriterT, + functorWriterT: functorWriterT, + applyWriterT: applyWriterT, + applicativeWriterT: applicativeWriterT, + altWriterT: altWriterT, + plusWriterT: plusWriterT, + alternativeWriterT: alternativeWriterT, + bindWriterT: bindWriterT, + monadWriterT: monadWriterT, + monadRecWriterT: monadRecWriterT, + monadZeroWriterT: monadZeroWriterT, + monadPlusWriterT: monadPlusWriterT, + monadTransWriterT: monadTransWriterT, + monadEffWriter: monadEffWriter, + monadContWriterT: monadContWriterT, + monadThrowWriterT: monadThrowWriterT, + monadErrorWriterT: monadErrorWriterT, + monadAskWriterT: monadAskWriterT, + monadReaderWriterT: monadReaderWriterT, + monadStateWriterT: monadStateWriterT, + monadTellWriterT: monadTellWriterT, + monadWriterWriterT: monadWriterWriterT+};++},{"../Control.Alt":38,"../Control.Alternative":39,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Monad":86,"../Control.Monad.Cont.Class":56,"../Control.Monad.Eff.Class":58,"../Control.Monad.Error.Class":71,"../Control.Monad.Reader.Class":75,"../Control.Monad.Rec.Class":77,"../Control.Monad.State.Class":80,"../Control.Monad.Trans.Class":83,"../Control.Monad.Writer.Class":84,"../Control.MonadPlus":87,"../Control.MonadZero":88,"../Control.Plus":91,"../Control.Semigroupoid":92,"../Data.Function":149,"../Data.Functor":155,"../Data.Monoid":207,"../Data.Newtype":209,"../Data.Semigroup":229,"../Data.Tuple":245,"../Data.Unit":249,"../Prelude":268}],86:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Data_Functor = require("../Data.Functor");+var Data_Unit = require("../Data.Unit");+var Monad = function (Applicative0, Bind1) {+ this.Applicative0 = Applicative0;+ this.Bind1 = Bind1;+};+var whenM = function (dictMonad) {+ return function (mb) {+ return function (m) {+ return Control_Bind.bind(dictMonad.Bind1())(mb)(function (v) {+ return Control_Applicative.when(dictMonad.Applicative0())(v)(m);+ });+ };+ };+};+var unlessM = function (dictMonad) {+ return function (mb) {+ return function (m) {+ return Control_Bind.bind(dictMonad.Bind1())(mb)(function (v) {+ return Control_Applicative.unless(dictMonad.Applicative0())(v)(m);+ });+ };+ };+};+var monadFn = new Monad(function () {+ return Control_Applicative.applicativeFn;+}, function () {+ return Control_Bind.bindFn;+});+var monadArray = new Monad(function () {+ return Control_Applicative.applicativeArray;+}, function () {+ return Control_Bind.bindArray;+});+var liftM1 = function (dictMonad) {+ return function (f) {+ return function (a) {+ return Control_Bind.bind(dictMonad.Bind1())(a)(function (v) {+ return Control_Applicative.pure(dictMonad.Applicative0())(f(v));+ });+ };+ };+};+var ap = function (dictMonad) {+ return function (f) {+ return function (a) {+ return Control_Bind.bind(dictMonad.Bind1())(f)(function (v) {+ return Control_Bind.bind(dictMonad.Bind1())(a)(function (v1) {+ return Control_Applicative.pure(dictMonad.Applicative0())(v(v1));+ });+ });+ };+ };+};+module.exports = {+ Monad: Monad, + ap: ap, + liftM1: liftM1, + unlessM: unlessM, + whenM: whenM, + monadFn: monadFn, + monadArray: monadArray+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Data.Functor":155,"../Data.Unit":249}],87:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Control_Alternative = require("../Control.Alternative");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Monad = require("../Control.Monad");+var Control_MonadZero = require("../Control.MonadZero");+var Control_Plus = require("../Control.Plus");+var Data_Functor = require("../Data.Functor");+var MonadPlus = function (MonadZero0) {+ this.MonadZero0 = MonadZero0;+};+var monadPlusArray = new MonadPlus(function () {+ return Control_MonadZero.monadZeroArray;+});+module.exports = {+ MonadPlus: MonadPlus, + monadPlusArray: monadPlusArray+};++},{"../Control.Alt":38,"../Control.Alternative":39,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Monad":86,"../Control.MonadZero":88,"../Control.Plus":91,"../Data.Functor":155}],88:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Control_Alternative = require("../Control.Alternative");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Monad = require("../Control.Monad");+var Control_Plus = require("../Control.Plus");+var Data_Functor = require("../Data.Functor");+var Data_Unit = require("../Data.Unit");+var MonadZero = function (Alternative1, Monad0) {+ this.Alternative1 = Alternative1;+ this.Monad0 = Monad0;+};+var monadZeroArray = new MonadZero(function () {+ return Control_Alternative.alternativeArray;+}, function () {+ return Control_Monad.monadArray;+});+var guard = function (dictMonadZero) {+ return function (v) {+ if (v) {+ return Control_Applicative.pure((dictMonadZero.Alternative1()).Applicative0())(Data_Unit.unit);+ };+ if (!v) {+ return Control_Plus.empty((dictMonadZero.Alternative1()).Plus1());+ };+ throw new Error("Failed pattern match at Control.MonadZero line 55, column 1 - line 55, column 23: " + [ v.constructor.name ]);+ };+};+module.exports = {+ MonadZero: MonadZero, + guard: guard, + monadZeroArray: monadZeroArray+};++},{"../Control.Alt":38,"../Control.Alternative":39,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Monad":86,"../Control.Plus":91,"../Data.Functor":155,"../Data.Unit":249}],89:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Control_Alternative = require("../Control.Alternative");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Monad_Cont_Trans = require("../Control.Monad.Cont.Trans");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var Control_Monad_Eff_Class = require("../Control.Monad.Eff.Class");+var Control_Monad_Eff_Ref = require("../Control.Monad.Eff.Ref");+var Control_Monad_Eff_Unsafe = require("../Control.Monad.Eff.Unsafe");+var Control_Monad_Except_Trans = require("../Control.Monad.Except.Trans");+var Control_Monad_Maybe_Trans = require("../Control.Monad.Maybe.Trans");+var Control_Monad_Reader_Trans = require("../Control.Monad.Reader.Trans");+var Control_Monad_Writer_Trans = require("../Control.Monad.Writer.Trans");+var Control_Plus = require("../Control.Plus");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Either = require("../Data.Either");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Functor_Compose = require("../Data.Functor.Compose");+var Data_Maybe = require("../Data.Maybe");+var Data_Monoid = require("../Data.Monoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../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 newtypeParCont = new Data_Newtype.Newtype(function (n) {+ return n;+}, ParCont);+var monadParWriterT = function (dictMonoid) {+ return function (dictParallel) {+ return new Parallel(function () {+ return Control_Monad_Writer_Trans.applicativeWriterT(dictMonoid)(dictParallel.Applicative1());+ }, function () {+ return Control_Monad_Writer_Trans.monadWriterT(dictMonoid)(dictParallel.Monad0());+ }, Control_Monad_Writer_Trans.mapWriterT(parallel(dictParallel)), Control_Monad_Writer_Trans.mapWriterT(sequential(dictParallel)));+ };+};+var monadParReaderT = function (dictParallel) {+ return new Parallel(function () {+ return Control_Monad_Reader_Trans.applicativeReaderT(dictParallel.Applicative1());+ }, function () {+ return Control_Monad_Reader_Trans.monadReaderT(dictParallel.Monad0());+ }, Control_Monad_Reader_Trans.mapReaderT(parallel(dictParallel)), Control_Monad_Reader_Trans.mapReaderT(sequential(dictParallel)));+};+var monadParMaybeT = function (dictParallel) {+ return new Parallel(function () {+ return Data_Functor_Compose.applicativeCompose(dictParallel.Applicative1())(Data_Maybe.applicativeMaybe);+ }, function () {+ return Control_Monad_Maybe_Trans.monadMaybeT(dictParallel.Monad0());+ }, function (v) {+ return parallel(dictParallel)(v);+ }, function (v) {+ return sequential(dictParallel)(v);+ });+};+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 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 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 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 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 altParCont = function (dictMonadEff) {+ return new Control_Alt.Alt(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(false))))(function (v2) {+ 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(v2))))(function (v3) {+ if (v3) {+ return Control_Applicative.pure((dictMonadEff.Monad0()).Applicative0())(Data_Unit.unit);+ };+ return Control_Bind.discard(Control_Bind.discardUnit)((dictMonadEff.Monad0()).Bind1())(Control_Monad_Eff_Class.liftEff(dictMonadEff)(unsafeWithRef(Control_Monad_Eff_Ref.writeRef(v2)(true))))(function () {+ return k(a);+ });+ });+ }))(function () {+ return Control_Monad_Cont_Trans.runContT(v1)(function (a) {+ return Control_Bind.bind((dictMonadEff.Monad0()).Bind1())(Control_Monad_Eff_Class.liftEff(dictMonadEff)(unsafeWithRef(Control_Monad_Eff_Ref.readRef(v2))))(function (v3) {+ if (v3) {+ return Control_Applicative.pure((dictMonadEff.Monad0()).Applicative0())(Data_Unit.unit);+ };+ return Control_Bind.discard(Control_Bind.discardUnit)((dictMonadEff.Monad0()).Bind1())(Control_Monad_Eff_Class.liftEff(dictMonadEff)(unsafeWithRef(Control_Monad_Eff_Ref.writeRef(v2)(true))))(function () {+ return k(a);+ });+ });+ });+ });+ });+ });+ };+ });+};+var plusParCont = function (dictMonadEff) {+ return new Control_Plus.Plus(function () {+ return altParCont(dictMonadEff);+ }, ParCont(function (v) {+ return Control_Applicative.pure((dictMonadEff.Monad0()).Applicative0())(Data_Unit.unit);+ }));+};+var alternativeParCont = function (dictMonadEff) {+ return new Control_Alternative.Alternative(function () {+ return applicativeParCont(dictMonadEff);+ }, function () {+ return plusParCont(dictMonadEff);+ });+};+module.exports = {+ ParCont: ParCont, + Parallel: Parallel, + parallel: parallel, + sequential: sequential, + monadParExceptT: monadParExceptT, + monadParReaderT: monadParReaderT, + monadParWriterT: monadParWriterT, + monadParMaybeT: monadParMaybeT, + newtypeParCont: newtypeParCont, + functorParCont: functorParCont, + applyParCont: applyParCont, + applicativeParCont: applicativeParCont, + altParCont: altParCont, + plusParCont: plusParCont, + alternativeParCont: alternativeParCont, + monadParParCont: monadParParCont+};++},{"../Control.Alt":38,"../Control.Alternative":39,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Monad.Cont.Trans":57,"../Control.Monad.Eff":70,"../Control.Monad.Eff.Class":58,"../Control.Monad.Eff.Ref":66,"../Control.Monad.Eff.Unsafe":68,"../Control.Monad.Except.Trans":72,"../Control.Monad.Maybe.Trans":74,"../Control.Monad.Reader.Trans":76,"../Control.Monad.Writer.Trans":85,"../Control.Plus":91,"../Control.Semigroupoid":92,"../Data.Either":136,"../Data.Function":149,"../Data.Functor":155,"../Data.Functor.Compose":151,"../Data.Maybe":198,"../Data.Monoid":207,"../Data.Newtype":209,"../Data.Unit":249,"../Prelude":268}],90:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var Control_Parallel_Class = require("../Control.Parallel.Class");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Foldable = require("../Data.Foldable");+var Data_Traversable = require("../Data.Traversable");+var Prelude = require("../Prelude");+var parTraverse_ = function (dictParallel) {+ return function (dictFoldable) {+ return function (f) {+ return function ($8) {+ return Control_Parallel_Class.sequential(dictParallel)(Data_Foldable.traverse_(dictParallel.Applicative1())(dictFoldable)(function ($9) {+ return Control_Parallel_Class.parallel(dictParallel)(f($9));+ })($8));+ };+ };+ };+};+var parTraverse = function (dictParallel) {+ return function (dictTraversable) {+ return function (f) {+ return function ($10) {+ return Control_Parallel_Class.sequential(dictParallel)(Data_Traversable.traverse(dictTraversable)(dictParallel.Applicative1())(function ($11) {+ return Control_Parallel_Class.parallel(dictParallel)(f($11));+ })($10));+ };+ };+ };+};+var parSequence_ = function (dictParallel) {+ return function (dictFoldable) {+ return parTraverse_(dictParallel)(dictFoldable)(Control_Category.id(Control_Category.categoryFn));+ };+};+var parSequence = function (dictParallel) {+ return function (dictTraversable) {+ return parTraverse(dictParallel)(dictTraversable)(Control_Category.id(Control_Category.categoryFn));+ };+};+module.exports = {+ parSequence: parSequence, + parSequence_: parSequence_, + parTraverse: parTraverse, + parTraverse_: parTraverse_+};++},{"../Control.Category":47,"../Control.Parallel.Class":89,"../Control.Semigroupoid":92,"../Data.Foldable":143,"../Data.Traversable":244,"../Prelude":268}],91:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Data_Functor = require("../Data.Functor");+var Plus = function (Alt0, empty) {+ this.Alt0 = Alt0;+ this.empty = empty;+};+var plusArray = new Plus(function () {+ return Control_Alt.altArray;+}, [ ]);+var empty = function (dict) {+ return dict.empty;+};+module.exports = {+ Plus: Plus, + empty: empty, + plusArray: plusArray+};++},{"../Control.Alt":38,"../Data.Functor":155}],92:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Semigroupoid = function (compose) {+ this.compose = compose;+};+var semigroupoidFn = new Semigroupoid(function (f) {+ return function (g) {+ return function (x) {+ return f(g(x));+ };+ };+});+var compose = function (dict) {+ return dict.compose;+};+var composeFlipped = function (dictSemigroupoid) {+ return function (f) {+ return function (g) {+ return compose(dictSemigroupoid)(g)(f);+ };+ };+};+module.exports = {+ Semigroupoid: Semigroupoid, + compose: compose, + composeFlipped: composeFlipped, + semigroupoidFn: semigroupoidFn+};++},{}],93:[function(require,module,exports){+/* global EventTarget */+"use strict";++exports._readEventTarget = function (left) {+ return function (right) {+ return function (foreign) {+ return foreign instanceof EventTarget ? left("Value is not an EventTarget") : right(foreign);+ };+ };+};++},{}],94:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Data_Either = require("../Data.Either");+var Data_Eq = require("../Data.Eq");+var Data_Foreign = require("../Data.Foreign");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Prelude = require("../Prelude");+var Unsafe_Coerce = require("../Unsafe.Coerce");+var EventType = function (x) {+ return x;+};+var wheelEventToEvent = Unsafe_Coerce.unsafeCoerce;+var uiEventToEvent = Unsafe_Coerce.unsafeCoerce;+var touchEventToEvent = Unsafe_Coerce.unsafeCoerce;+var readWheelEvent = Data_Foreign.unsafeReadTagged("WheelEvent");+var readUIEvent = Data_Foreign.unsafeReadTagged("UIEvent");+var readTouchEvent = Data_Foreign.unsafeReadTagged("TouchEvent");+var readProgressEvent = Data_Foreign.unsafeReadTagged("ProgressEvent");+var readMouseEvent = Data_Foreign.unsafeReadTagged("MouseEvent");+var readKeyboardEvent = Data_Foreign.unsafeReadTagged("KeyboardEvent");+var readInputEvent = Data_Foreign.unsafeReadTagged("InputEvent");+var readFocusEvent = Data_Foreign.unsafeReadTagged("FocusEvent");+var readEventTarget = $foreign._readEventTarget(Data_Either.Left.create)(Data_Either.Right.create);+var readCustomEvent = Data_Foreign.unsafeReadTagged("CustomEvent");+var readCompositionEvent = Data_Foreign.unsafeReadTagged("CompositionEvent");+var readClipboardEvent = Data_Foreign.unsafeReadTagged("ClipboardEvent");+var progressEventToEvent = Unsafe_Coerce.unsafeCoerce;+var ordEventType = Data_Ord.ordString;+var newtypeEventType = new Data_Newtype.Newtype(function (n) {+ return n;+}, EventType);+var mouseEventToEvent = Unsafe_Coerce.unsafeCoerce;+var keyboardEventToEvent = Unsafe_Coerce.unsafeCoerce;+var inputEventToEvent = Unsafe_Coerce.unsafeCoerce;+var focusEventToEvent = Unsafe_Coerce.unsafeCoerce;+var eqEventType = Data_Eq.eqString;+var customEventToEvent = Unsafe_Coerce.unsafeCoerce;+var compositionEventToEvent = Unsafe_Coerce.unsafeCoerce;+var clipboardEventToEvent = Unsafe_Coerce.unsafeCoerce;+module.exports = {+ EventType: EventType, + clipboardEventToEvent: clipboardEventToEvent, + compositionEventToEvent: compositionEventToEvent, + customEventToEvent: customEventToEvent, + focusEventToEvent: focusEventToEvent, + inputEventToEvent: inputEventToEvent, + keyboardEventToEvent: keyboardEventToEvent, + mouseEventToEvent: mouseEventToEvent, + progressEventToEvent: progressEventToEvent, + readClipboardEvent: readClipboardEvent, + readCompositionEvent: readCompositionEvent, + readCustomEvent: readCustomEvent, + readEventTarget: readEventTarget, + readFocusEvent: readFocusEvent, + readInputEvent: readInputEvent, + readKeyboardEvent: readKeyboardEvent, + readMouseEvent: readMouseEvent, + readProgressEvent: readProgressEvent, + readTouchEvent: readTouchEvent, + readUIEvent: readUIEvent, + readWheelEvent: readWheelEvent, + touchEventToEvent: touchEventToEvent, + uiEventToEvent: uiEventToEvent, + wheelEventToEvent: wheelEventToEvent, + newtypeEventType: newtypeEventType, + eqEventType: eqEventType, + ordEventType: ordEventType+};++},{"../Data.Either":136,"../Data.Eq":138,"../Data.Foreign":145,"../Data.Newtype":209,"../Data.Ord":216,"../Prelude":268,"../Unsafe.Coerce":271,"./foreign":93}],95:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var DOM_Event_Types = require("../DOM.Event.Types");+var Data_Foreign = require("../Data.Foreign");+var Unsafe_Coerce = require("../Unsafe.Coerce");+var readFileList = Data_Foreign.unsafeReadTagged("FileList");+var fileToBlob = Unsafe_Coerce.unsafeCoerce;+var fileReaderToEventTarget = Unsafe_Coerce.unsafeCoerce;+module.exports = {+ fileReaderToEventTarget: fileReaderToEventTarget, + fileToBlob: fileToBlob, + readFileList: readFileList+};++},{"../DOM.Event.Types":94,"../Data.Foreign":145,"../Unsafe.Coerce":271}],96:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var DOM_Event_Types = require("../DOM.Event.Types");+var DOM_Util_FFI = require("../DOM.Util.FFI");+var Data_Eq = require("../Data.Eq");+var Data_Foreign = require("../Data.Foreign");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Prelude = require("../Prelude");+var Unsafe_Coerce = require("../Unsafe.Coerce");+var ElementId = function (x) {+ return x;+};+var textToNode = Unsafe_Coerce.unsafeCoerce;+var readNode = DOM_Util_FFI.unsafeReadProtoTagged("Node");+var readElement = DOM_Util_FFI.unsafeReadProtoTagged("Element");+var readDocument = DOM_Util_FFI.unsafeReadProtoTagged("Document");+var processingInstructionToNode = Unsafe_Coerce.unsafeCoerce;+var oOrdElementId = Data_Ord.ordString;+var newtypeElementId = new Data_Newtype.Newtype(function (n) {+ return n;+}, ElementId);+var eqElementId = Data_Eq.eqString;+var elementToParentNode = Unsafe_Coerce.unsafeCoerce;+var elementToNonDocumentTypeChildNode = Unsafe_Coerce.unsafeCoerce;+var elementToNode = Unsafe_Coerce.unsafeCoerce;+var elementToEventTarget = Unsafe_Coerce.unsafeCoerce;+var documentTypeToNode = Unsafe_Coerce.unsafeCoerce;+var documentToParentNode = Unsafe_Coerce.unsafeCoerce;+var documentToNonElementParentNode = Unsafe_Coerce.unsafeCoerce;+var documentToNode = Unsafe_Coerce.unsafeCoerce;+var documentToEventTarget = Unsafe_Coerce.unsafeCoerce;+var documentFragmentToParentNode = Unsafe_Coerce.unsafeCoerce;+var documentFragmentToNonElementParentNode = Unsafe_Coerce.unsafeCoerce;+var documentFragmentToNode = Unsafe_Coerce.unsafeCoerce;+var commentToNode = Unsafe_Coerce.unsafeCoerce;+var characterDataToNonDocumentTypeChildNode = Unsafe_Coerce.unsafeCoerce;+module.exports = {+ ElementId: ElementId, + characterDataToNonDocumentTypeChildNode: characterDataToNonDocumentTypeChildNode, + commentToNode: commentToNode, + documentFragmentToNode: documentFragmentToNode, + documentFragmentToNonElementParentNode: documentFragmentToNonElementParentNode, + documentFragmentToParentNode: documentFragmentToParentNode, + documentToEventTarget: documentToEventTarget, + documentToNode: documentToNode, + documentToNonElementParentNode: documentToNonElementParentNode, + documentToParentNode: documentToParentNode, + documentTypeToNode: documentTypeToNode, + elementToEventTarget: elementToEventTarget, + elementToNode: elementToNode, + elementToNonDocumentTypeChildNode: elementToNonDocumentTypeChildNode, + elementToParentNode: elementToParentNode, + processingInstructionToNode: processingInstructionToNode, + readDocument: readDocument, + readElement: readElement, + readNode: readNode, + textToNode: textToNode, + newtypeElementId: newtypeElementId, + eqElementId: eqElementId, + oOrdElementId: oOrdElementId+};++},{"../DOM.Event.Types":94,"../DOM.Util.FFI":98,"../Data.Eq":138,"../Data.Foreign":145,"../Data.Newtype":209,"../Data.Ord":216,"../Prelude":268,"../Unsafe.Coerce":271}],97:[function(require,module,exports){+"use strict";++exports._unsafeReadProtoTagged = function (name) {+ return function (failure) {+ return function (success) {+ return function (value) {+ var obj = value;+ while (obj != null) {+ var proto = Object.getPrototypeOf(obj);+ var ctor = proto.constructor.name;+ if (ctor === name) {+ return success(value);+ } else if (ctor === "Object") {+ return failure(Object.getPrototypeOf(value).constructor.name);+ }+ obj = proto;+ }+ return failure(Object.getPrototypeOf(value).constructor.name);+ };+ };+ };+};++},{}],98:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Applicative = require("../Control.Applicative");+var Control_Monad_Except = require("../Control.Monad.Except");+var Control_Monad_Except_Trans = require("../Control.Monad.Except.Trans");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Either = require("../Data.Either");+var Data_Foreign = require("../Data.Foreign");+var Data_Identity = require("../Data.Identity");+var Data_List_Types = require("../Data.List.Types");+var Prelude = require("../Prelude");+var unsafeReadProtoTagged = function (name) {+ return $foreign._unsafeReadProtoTagged(name)(function ($0) {+ return Control_Monad_Except_Trans.except(Data_Identity.applicativeIdentity)(Data_Either.Left.create(Control_Applicative.pure(Data_List_Types.applicativeNonEmptyList)(Data_Foreign.TypeMismatch.create(name)($0))));+ })(function ($1) {+ return Control_Monad_Except_Trans.except(Data_Identity.applicativeIdentity)(Data_Either.Right.create($1));+ });+};+module.exports = {+ unsafeReadProtoTagged: unsafeReadProtoTagged+};++},{"../Control.Applicative":40,"../Control.Monad.Except":73,"../Control.Monad.Except.Trans":72,"../Control.Semigroupoid":92,"../Data.Either":136,"../Data.Foreign":145,"../Data.Identity":161,"../Data.List.Types":193,"../Prelude":268,"./foreign":97}],99:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+module.exports = {};++},{}],100:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Monad_Eff = require("../Control.Monad.Eff");+module.exports = {};++},{"../Control.Monad.Eff":70}],101:[function(require,module,exports){+"use strict";++function id(x) {+ return x;+}++exports.fromNull = function () {+ return null;+};++exports.fromBoolean = id;+exports.fromNumber = id;+exports.fromString = id;+exports.fromArray = id;+exports.fromObject = id;++exports.jsonNull = null;++exports.stringify = function (j) {+ return JSON.stringify(j);+};++var objToString = Object.prototype.toString;+var objKeys = Object.keys;++function isArray(a) {+ return objToString.call(a) === "[object Array]";+}++exports._foldJson = function (isNull, isBool, isNum, isStr, isArr, isObj, j) {+ if (j == null) return isNull(null);+ else if (typeof j === "boolean") return isBool(j);+ else if (typeof j === "number") return isNum(j);+ else if (typeof j === "string") return isStr(j);+ else if (objToString.call(j) === "[object Array]")+ return isArr(j);+ else return isObj(j);+};++exports._compare = function _compare (EQ, GT, LT, a, b) {+ if (a == null) {+ if (b == null) return EQ;+ else return LT;+ } else if (typeof a === "boolean") {+ if (typeof b === "boolean") {+ // boolean / boolean+ if (a === b) return EQ;+ else if (a === false) return LT;+ else return GT;+ } else if (b == null) return GT;+ else return LT;+ } else if (typeof a === "number") {+ if (typeof b === "number") {+ if (a === b) return EQ;+ else if (a < b) return LT;+ else return GT;+ } else if (b == null) return GT;+ else if (typeof b === "boolean") return GT;+ else return LT;+ } else if (typeof a === "string") {+ if (typeof b === "string") {+ if (a === b) return EQ;+ else if (a < b) return LT;+ else return GT;+ } else if (b == null) return GT;+ else if (typeof b === "boolean") return GT;+ else if (typeof b === "number") return GT;+ else return LT;+ } else if (isArray(a)) {+ if (isArray(b)) {+ for (var i = 0; i < Math.min(a.length, b.length); i++) {+ var ca = _compare(EQ, GT, LT, a[i], b[i]);+ if (ca !== EQ) return ca;+ }+ if (a.length === b.length) return EQ;+ else if (a.length < b.length) return LT;+ else return GT;+ } else if (b == null) return GT;+ else if (typeof b === "boolean") return GT;+ else if (typeof b === "number") return GT;+ else if (typeof b === "string") return GT;+ else return LT;+ } else {+ if (b == null) return GT;+ else if (typeof b === "boolean") return GT;+ else if (typeof b === "number") return GT;+ else if (typeof b === "string") return GT;+ else if (isArray(b)) return GT;+ else {+ var akeys = objKeys(a);+ var bkeys = objKeys(b);+ if (akeys.length < bkeys.length) return LT;+ else if (akeys.length > bkeys.length) return GT;+ var keys = akeys.concat(bkeys).sort();+ for (var j = 0; j < keys.length; j++) {+ var k = keys[j];+ if (a[k] === undefined) return LT;+ else if (b[k] === undefined) return GT;+ var ck = _compare(EQ, GT, LT, a[k], b[k]);+ if (ck !== EQ) return ck;+ }+ return EQ;+ }+ }+};++},{}],102:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Data_Eq = require("../Data.Eq");+var Data_Function = require("../Data.Function");+var Data_Function_Uncurried = require("../Data.Function.Uncurried");+var Data_Maybe = require("../Data.Maybe");+var Data_Ord = require("../Data.Ord");+var Data_Ordering = require("../Data.Ordering");+var Data_Show = require("../Data.Show");+var Data_StrMap = require("../Data.StrMap");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var Unsafe_Coerce = require("../Unsafe.Coerce");+var verbJsonType = function (def) {+ return function (f) {+ return function (fold) {+ return fold(def)(f);+ };+ };+};+var toJsonType = verbJsonType(Data_Maybe.Nothing.value)(Data_Maybe.Just.create);+var showJson = new Data_Show.Show($foreign.stringify);+var showJNull = new Data_Show.Show(function (v) {+ return "null";+});+var jsonZero = $foreign.fromNumber(0.0);+var jsonTrue = $foreign.fromBoolean(true);+var jsonSingletonObject = function (key) {+ return function (val) {+ return $foreign.fromObject(Data_StrMap.singleton(key)(val));+ };+};+var jsonSingletonArray = function (j) {+ return $foreign.fromArray([ j ]);+};+var jsonFalse = $foreign.fromBoolean(false);+var jsonEmptyString = $foreign.fromString("");+var jsonEmptyObject = $foreign.fromObject(Data_StrMap.empty);+var jsonEmptyArray = $foreign.fromArray([ ]);+var jNull = Unsafe_Coerce.unsafeCoerce($foreign.jsonNull);+var isJsonType = verbJsonType(false)(Data_Function["const"](true));+var foldJsonString = function (d) {+ return function (f) {+ return function (j) {+ return $foreign._foldJson(Data_Function["const"](d), Data_Function["const"](d), Data_Function["const"](d), f, Data_Function["const"](d), Data_Function["const"](d), j);+ };+ };+};+var isString = isJsonType(foldJsonString);+var toString = toJsonType(foldJsonString);+var foldJsonObject = function (d) {+ return function (f) {+ return function (j) {+ return $foreign._foldJson(Data_Function["const"](d), Data_Function["const"](d), Data_Function["const"](d), Data_Function["const"](d), Data_Function["const"](d), f, j);+ };+ };+};+var isObject = isJsonType(foldJsonObject);+var toObject = toJsonType(foldJsonObject);+var foldJsonNumber = function (d) {+ return function (f) {+ return function (j) {+ return $foreign._foldJson(Data_Function["const"](d), Data_Function["const"](d), f, Data_Function["const"](d), Data_Function["const"](d), Data_Function["const"](d), j);+ };+ };+};+var isNumber = isJsonType(foldJsonNumber);+var toNumber = toJsonType(foldJsonNumber);+var foldJsonNull = function (d) {+ return function (f) {+ return function (j) {+ return $foreign._foldJson(f, Data_Function["const"](d), Data_Function["const"](d), Data_Function["const"](d), Data_Function["const"](d), Data_Function["const"](d), j);+ };+ };+};+var isNull = isJsonType(foldJsonNull);+var toNull = toJsonType(foldJsonNull);+var foldJsonBoolean = function (d) {+ return function (f) {+ return function (j) {+ return $foreign._foldJson(Data_Function["const"](d), f, Data_Function["const"](d), Data_Function["const"](d), Data_Function["const"](d), Data_Function["const"](d), j);+ };+ };+};+var isBoolean = isJsonType(foldJsonBoolean);+var toBoolean = toJsonType(foldJsonBoolean);+var foldJsonArray = function (d) {+ return function (f) {+ return function (j) {+ return $foreign._foldJson(Data_Function["const"](d), Data_Function["const"](d), Data_Function["const"](d), Data_Function["const"](d), f, Data_Function["const"](d), j);+ };+ };+};+var isArray = isJsonType(foldJsonArray);+var toArray = toJsonType(foldJsonArray);+var foldJson = function (a) {+ return function (b) {+ return function (c) {+ return function (d) {+ return function (e) {+ return function (f) {+ return function (json) {+ return $foreign._foldJson(a, b, c, d, e, f, json);+ };+ };+ };+ };+ };+ };+};+var ordJson = new Data_Ord.Ord(function () {+ return eqJson;+}, function (a) {+ return function (b) {+ return $foreign._compare(Data_Ordering.EQ.value, Data_Ordering.GT.value, Data_Ordering.LT.value, a, b);+ };+});+var eqJson = new Data_Eq.Eq(function (j1) {+ return function (j2) {+ return Data_Eq.eq(Data_Ordering.eqOrdering)(Data_Ord.compare(ordJson)(j1)(j2))(Data_Ordering.EQ.value);+ };+});+var eqJNull = new Data_Eq.Eq(function (v) {+ return function (v1) {+ return true;+ };+});+var ordJNull = new Data_Ord.Ord(function () {+ return eqJNull;+}, function (v) {+ return function (v1) {+ return Data_Ordering.EQ.value;+ };+});+module.exports = {+ foldJson: foldJson, + foldJsonArray: foldJsonArray, + foldJsonBoolean: foldJsonBoolean, + foldJsonNull: foldJsonNull, + foldJsonNumber: foldJsonNumber, + foldJsonObject: foldJsonObject, + foldJsonString: foldJsonString, + isArray: isArray, + isBoolean: isBoolean, + isNull: isNull, + isNumber: isNumber, + isObject: isObject, + isString: isString, + jNull: jNull, + jsonEmptyArray: jsonEmptyArray, + jsonEmptyObject: jsonEmptyObject, + jsonEmptyString: jsonEmptyString, + jsonFalse: jsonFalse, + jsonSingletonArray: jsonSingletonArray, + jsonSingletonObject: jsonSingletonObject, + jsonTrue: jsonTrue, + jsonZero: jsonZero, + toArray: toArray, + toBoolean: toBoolean, + toNull: toNull, + toNumber: toNumber, + toObject: toObject, + toString: toString, + eqJNull: eqJNull, + ordJNull: ordJNull, + showJNull: showJNull, + eqJson: eqJson, + ordJson: ordJson, + showJson: showJson, + fromArray: $foreign.fromArray, + fromBoolean: $foreign.fromBoolean, + fromNull: $foreign.fromNull, + fromNumber: $foreign.fromNumber, + fromObject: $foreign.fromObject, + fromString: $foreign.fromString, + jsonNull: $foreign.jsonNull, + stringify: $foreign.stringify+};++},{"../Data.Eq":138,"../Data.Function":149,"../Data.Function.Uncurried":148,"../Data.Maybe":198,"../Data.Ord":216,"../Data.Ordering":217,"../Data.Show":233,"../Data.StrMap":237,"../Data.Tuple":245,"../Prelude":268,"../Unsafe.Coerce":271,"./foreign":101}],103:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Argonaut_Core = require("../Data.Argonaut.Core");+var Data_Bifunctor = require("../Data.Bifunctor");+var Data_Boolean = require("../Data.Boolean");+var Data_Either = require("../Data.Either");+var Data_Foldable = require("../Data.Foldable");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Int = require("../Data.Int");+var Data_List = require("../Data.List");+var Data_List_Types = require("../Data.List.Types");+var Data_Map = require("../Data.Map");+var Data_Maybe = require("../Data.Maybe");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Data_StrMap = require("../Data.StrMap");+var Data_String = require("../Data.String");+var Data_Traversable = require("../Data.Traversable");+var Data_Tuple = require("../Data.Tuple");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var DecodeJson = function (decodeJson) {+ this.decodeJson = decodeJson;+};+var decodeVoid = new DecodeJson(function (v) {+ return new Data_Either.Left("Value cannot be Void");+});+var decodeJsonString = new DecodeJson(Data_Argonaut_Core.foldJsonString(new Data_Either.Left("Value is not a String"))(Data_Either.Right.create));+var decodeJsonNumber = new DecodeJson(Data_Argonaut_Core.foldJsonNumber(new Data_Either.Left("Value is not a Number"))(Data_Either.Right.create));+var decodeJsonNull = new DecodeJson(Data_Argonaut_Core.foldJsonNull(new Data_Either.Left("Value is not a null"))(Data_Function["const"](new Data_Either.Right(Data_Unit.unit))));+var decodeJsonJson = new DecodeJson(Data_Either.Right.create);+var decodeJsonBoolean = new DecodeJson(Data_Argonaut_Core.foldJsonBoolean(new Data_Either.Left("Value is not a Boolean"))(Data_Either.Right.create));+var decodeJson = function (dict) {+ return dict.decodeJson;+};+var decodeJsonChar = new DecodeJson(function (j) {+ return Control_Bind.bindFlipped(Data_Either.bindEither)(Data_Maybe.maybe(Data_Either.Left.create("Expected character but found: " + Data_Show.show(Data_Argonaut_Core.showJson)(j)))(Data_Either.Right.create))(Data_Functor.map(Data_Either.functorEither)(Data_String.charAt(0))(decodeJson(decodeJsonString)(j)));+});+var decodeJsonInt = new DecodeJson(Control_Bind.composeKleisliFlipped(Data_Either.bindEither)(function ($36) {+ return Data_Maybe.maybe(new Data_Either.Left("Value is not an integer"))(Data_Either.Right.create)(Data_Int.fromNumber($36));+})(decodeJson(decodeJsonNumber)));+var decodeJObject = function ($37) {+ return Data_Maybe.maybe(new Data_Either.Left("Value is not an Object"))(Data_Either.Right.create)(Data_Argonaut_Core.toObject($37));+};+var decodeJsonEither = function (dictDecodeJson) {+ return function (dictDecodeJson1) {+ return new DecodeJson(function (json) {+ return Data_Bifunctor.lmap(Data_Either.bifunctorEither)(function (v) {+ return "Couldn't decode Either: " + v;+ })(Control_Bind.bind(Data_Either.bindEither)(decodeJObject(json))(function (obj) {+ return Control_Bind.bind(Data_Either.bindEither)(Data_Maybe.maybe(new Data_Either.Left("Expected field 'tag'"))(Data_Either.Right.create)(Data_StrMap.lookup("tag")(obj)))(function (v) {+ return Control_Bind.bind(Data_Either.bindEither)(Data_Maybe.maybe(new Data_Either.Left("Expected field 'value'"))(Data_Either.Right.create)(Data_StrMap.lookup("value")(obj)))(function (v1) {+ var v2 = Data_Argonaut_Core.toString(v);+ if (v2 instanceof Data_Maybe.Just && v2.value0 === "Right") {+ return Data_Functor.map(Data_Either.functorEither)(Data_Either.Right.create)(decodeJson(dictDecodeJson1)(v1));+ };+ if (v2 instanceof Data_Maybe.Just && v2.value0 === "Left") {+ return Data_Functor.map(Data_Either.functorEither)(Data_Either.Left.create)(decodeJson(dictDecodeJson)(v1));+ };+ return new Data_Either.Left("'tag' field was not \"Left\" or \"Right\"");+ });+ });+ }));+ });+ };+};+var decodeJsonMaybe = function (dictDecodeJson) {+ return new DecodeJson(function (j) {+ var lookupJust = function ($38) {+ return Data_Maybe.maybe(new Data_Either.Left("Missing property 'just'"))(Data_Either.Right.create)(Data_StrMap.lookup("just")($38));+ };+ var decode = Control_Bind.composeKleisli(Data_Either.bindEither)(decodeJObject)(Control_Bind.composeKleisli(Data_Either.bindEither)(lookupJust)(decodeJson(decodeJsonMaybe(dictDecodeJson))));+ var backwardsCompat = (function () {+ if (Data_Argonaut_Core.isNull(j)) {+ return Control_Applicative.pure(Data_Either.applicativeEither)(Data_Maybe.Nothing.value);+ };+ if (Data_Boolean.otherwise) {+ return Data_Functor.map(Data_Either.functorEither)(Data_Maybe.Just.create)(decodeJson(dictDecodeJson)(j));+ };+ throw new Error("Failed pattern match at Data.Argonaut.Decode.Class line 25, column 7 - line 35, column 42: " + [ ]);+ })();+ var v = decode(j);+ if (v instanceof Data_Either.Right) {+ return new Data_Either.Right(v.value0);+ };+ if (v instanceof Data_Either.Left) {+ return backwardsCompat;+ };+ throw new Error("Failed pattern match at Data.Argonaut.Decode.Class line 25, column 7 - line 27, column 34: " + [ v.constructor.name ]);+ });+};+var decodeStrMap = function (dictDecodeJson) {+ return new DecodeJson(function ($39) {+ return Data_Bifunctor.lmap(Data_Either.bifunctorEither)(function (v) {+ return "Couldn't decode StrMap: " + v;+ })(Control_Bind.composeKleisliFlipped(Data_Either.bindEither)(Data_Traversable.traverse(Data_StrMap.traversableStrMap)(Data_Either.applicativeEither)(decodeJson(dictDecodeJson)))(decodeJObject)($39));+ });+};+var decodeJArray = function ($40) {+ return Data_Maybe.maybe(new Data_Either.Left("Value is not an Array"))(Data_Either.Right.create)(Data_Argonaut_Core.toArray($40));+};+var decodeList = function (dictDecodeJson) {+ return new DecodeJson(function ($41) {+ return Data_Bifunctor.lmap(Data_Either.bifunctorEither)(function (v) {+ return "Couldn't decode List: " + v;+ })(Control_Bind.composeKleisliFlipped(Data_Either.bindEither)(Data_Traversable.traverse(Data_List_Types.traversableList)(Data_Either.applicativeEither)(decodeJson(dictDecodeJson)))(Data_Functor.map(Data_Functor.functorFn)(Data_Functor.map(Data_Either.functorEither)(Data_List.fromFoldable(Data_Foldable.foldableArray)))(decodeJArray))($41));+ });+};+var decodeJsonTuple = function (dictDecodeJson) {+ return function (dictDecodeJson1) {+ return new DecodeJson(function (j) {+ var f = function (v) {+ if (v instanceof Data_List_Types.Cons && (v.value1 instanceof Data_List_Types.Cons && v.value1.value1 instanceof Data_List_Types.Nil)) {+ return Control_Apply.apply(Data_Either.applyEither)(Data_Functor.map(Data_Either.functorEither)(Data_Tuple.Tuple.create)(decodeJson(dictDecodeJson)(v.value0)))(decodeJson(dictDecodeJson1)(v.value1.value0));+ };+ return new Data_Either.Left("Couldn't decode Tuple");+ };+ return Control_Bind.bind(Data_Either.bindEither)(decodeJson(decodeList(decodeJsonJson))(j))(f);+ });+ };+};+var decodeMap = function (dictOrd) {+ return function (dictDecodeJson) {+ return function (dictDecodeJson1) {+ return new DecodeJson(function ($42) {+ return Data_Functor.map(Data_Either.functorEither)(Data_Map.fromFoldable(dictOrd)(Data_List_Types.foldableList))(decodeJson(decodeList(decodeJsonTuple(dictDecodeJson)(dictDecodeJson1)))($42));+ });+ };+ };+};+var decodeArray = function (dictDecodeJson) {+ return new DecodeJson(function ($43) {+ return Data_Bifunctor.lmap(Data_Either.bifunctorEither)(function (v) {+ return "Couldn't decode Array: " + v;+ })(Control_Bind.composeKleisliFlipped(Data_Either.bindEither)(Data_Traversable.traverse(Data_Traversable.traversableArray)(Data_Either.applicativeEither)(decodeJson(dictDecodeJson)))(decodeJArray)($43));+ });+};+module.exports = {+ DecodeJson: DecodeJson, + decodeJson: decodeJson, + decodeJsonMaybe: decodeJsonMaybe, + decodeJsonTuple: decodeJsonTuple, + decodeJsonEither: decodeJsonEither, + decodeJsonNull: decodeJsonNull, + decodeJsonBoolean: decodeJsonBoolean, + decodeJsonNumber: decodeJsonNumber, + decodeJsonInt: decodeJsonInt, + decodeJsonString: decodeJsonString, + decodeJsonJson: decodeJsonJson, + decodeJsonChar: decodeJsonChar, + decodeStrMap: decodeStrMap, + decodeArray: decodeArray, + decodeList: decodeList, + decodeMap: decodeMap, + decodeVoid: decodeVoid+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Semigroupoid":92,"../Data.Argonaut.Core":102,"../Data.Bifunctor":127,"../Data.Boolean":129,"../Data.Either":136,"../Data.Foldable":143,"../Data.Function":149,"../Data.Functor":155,"../Data.Int":165,"../Data.List":194,"../Data.List.Types":193,"../Data.Map":195,"../Data.Maybe":198,"../Data.Semigroup":229,"../Data.Show":233,"../Data.StrMap":237,"../Data.String":241,"../Data.Traversable":244,"../Data.Tuple":245,"../Data.Unit":249,"../Prelude":268}],104:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Data_Argonaut_Core = require("../Data.Argonaut.Core");+var Data_Argonaut_Decode_Class = require("../Data.Argonaut.Decode.Class");+var Data_Either = require("../Data.Either");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Maybe = require("../Data.Maybe");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Data_StrMap = require("../Data.StrMap");+var Prelude = require("../Prelude");+var getFieldOptional = function (dictDecodeJson) {+ return function (o) {+ return function (s) {+ var decode = function (json) {+ return Data_Functor.map(Data_Either.functorEither)(Data_Maybe.Just.create)(Data_Argonaut_Decode_Class.decodeJson(dictDecodeJson)(json));+ };+ return Data_Maybe.maybe(Control_Applicative.pure(Data_Either.applicativeEither)(Data_Maybe.Nothing.value))(decode)(Data_StrMap.lookup(s)(o));+ };+ };+};+var getField = function (dictDecodeJson) {+ return function (o) {+ return function (s) {+ return Data_Maybe.maybe(Data_Either.Left.create("Expected field " + Data_Show.show(Data_Show.showString)(s)))(Data_Argonaut_Decode_Class.decodeJson(dictDecodeJson))(Data_StrMap.lookup(s)(o));+ };+ };+};+module.exports = {+ getField: getField, + getFieldOptional: getFieldOptional+};++},{"../Control.Applicative":40,"../Data.Argonaut.Core":102,"../Data.Argonaut.Decode.Class":103,"../Data.Either":136,"../Data.Function":149,"../Data.Functor":155,"../Data.Maybe":198,"../Data.Semigroup":229,"../Data.Show":233,"../Data.StrMap":237,"../Prelude":268}],105:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Argonaut_Decode_Class = require("../Data.Argonaut.Decode.Class");+var Data_Argonaut_Decode_Combinators = require("../Data.Argonaut.Decode.Combinators");+module.exports = {};++},{"../Data.Argonaut.Decode.Class":103,"../Data.Argonaut.Decode.Combinators":104}],106:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Argonaut_Core = require("../Data.Argonaut.Core");+var Data_Either = require("../Data.Either");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Int = require("../Data.Int");+var Data_List = require("../Data.List");+var Data_List_Types = require("../Data.List.Types");+var Data_Map = require("../Data.Map");+var Data_Maybe = require("../Data.Maybe");+var Data_StrMap = require("../Data.StrMap");+var Data_String = require("../Data.String");+var Data_Tuple = require("../Data.Tuple");+var Data_Unfoldable = require("../Data.Unfoldable");+var Data_Void = require("../Data.Void");+var Prelude = require("../Prelude");+var EncodeJson = function (encodeJson) {+ this.encodeJson = encodeJson;+};+var encodeVoid = new EncodeJson(Data_Void.absurd);+var encodeJsonUnit = new EncodeJson(Data_Function["const"](Data_Argonaut_Core.jsonNull));+var encodeJsonJson = new EncodeJson(Control_Category.id(Control_Category.categoryFn));+var encodeJsonJString = new EncodeJson(Data_Argonaut_Core.fromString);+var encodeJsonJNumber = new EncodeJson(Data_Argonaut_Core.fromNumber);+var encodeJsonJBoolean = new EncodeJson(Data_Argonaut_Core.fromBoolean);+var encodeJsonInt = new EncodeJson(function ($19) {+ return Data_Argonaut_Core.fromNumber(Data_Int.toNumber($19));+});+var encodeJson = function (dict) {+ return dict.encodeJson;+};+var encodeJsonArray = function (dictEncodeJson) {+ return new EncodeJson(function (json) {+ return Data_Argonaut_Core.fromArray(Data_Functor.map(Data_Functor.functorArray)(encodeJson(dictEncodeJson))(json));+ });+};+var encodeJsonChar = new EncodeJson(function ($20) {+ return encodeJson(encodeJsonJString)(Data_String.singleton($20));+});+var encodeJsonEither = function (dictEncodeJson) {+ return function (dictEncodeJson1) {+ return new EncodeJson((function () {+ var obj = function (dictEncodeJson2) {+ return function (tag) {+ return function (x) {+ return Data_Argonaut_Core.fromObject(Data_StrMap.fromFoldable(Data_List_Types.foldableList)(new Data_List_Types.Cons(new Data_Tuple.Tuple("tag", Data_Argonaut_Core.fromString(tag)), new Data_List_Types.Cons(new Data_Tuple.Tuple("value", encodeJson(dictEncodeJson2)(x)), Data_List_Types.Nil.value))));+ };+ };+ };+ return Data_Either.either(obj(dictEncodeJson)("Left"))(obj(dictEncodeJson1)("Right"));+ })());+ };+};+var encodeJsonList = function (dictEncodeJson) {+ return new EncodeJson(function ($21) {+ return Data_Argonaut_Core.fromArray(Data_Functor.map(Data_Functor.functorArray)(encodeJson(dictEncodeJson))(Data_List.toUnfoldable(Data_Unfoldable.unfoldableArray)($21)));+ });+};+var encodeJsonMaybe = function (dictEncodeJson) {+ return new EncodeJson(function (v) {+ if (v instanceof Data_Maybe.Nothing) {+ return Data_Argonaut_Core.jsonEmptyObject;+ };+ if (v instanceof Data_Maybe.Just) {+ return Data_Argonaut_Core.jsonSingletonObject("just")(encodeJson(dictEncodeJson)(v.value0));+ };+ throw new Error("Failed pattern match at Data.Argonaut.Encode.Class line 19, column 3 - line 19, column 40: " + [ v.constructor.name ]);+ });+};+var encodeJsonTuple = function (dictEncodeJson) {+ return function (dictEncodeJson1) {+ return new EncodeJson(function (v) {+ return encodeJson(encodeJsonArray(encodeJsonJson))([ encodeJson(dictEncodeJson)(v.value0), encodeJson(dictEncodeJson1)(v.value1) ]);+ });+ };+};+var encodeMap = function (dictOrd) {+ return function (dictEncodeJson) {+ return function (dictEncodeJson1) {+ return new EncodeJson(function ($22) {+ return encodeJson(encodeJsonList(encodeJsonTuple(dictEncodeJson)(dictEncodeJson1)))(Data_Map.toUnfoldable(Data_List_Types.unfoldableList)($22));+ });+ };+ };+};+var encodeStrMap = function (dictEncodeJson) {+ return new EncodeJson(function ($23) {+ return Data_Argonaut_Core.fromObject(Data_Functor.map(Data_StrMap.functorStrMap)(encodeJson(dictEncodeJson))($23));+ });+};+module.exports = {+ EncodeJson: EncodeJson, + encodeJson: encodeJson, + encodeJsonMaybe: encodeJsonMaybe, + encodeJsonTuple: encodeJsonTuple, + encodeJsonEither: encodeJsonEither, + encodeJsonUnit: encodeJsonUnit, + encodeJsonJBoolean: encodeJsonJBoolean, + encodeJsonJNumber: encodeJsonJNumber, + encodeJsonInt: encodeJsonInt, + encodeJsonJString: encodeJsonJString, + encodeJsonJson: encodeJsonJson, + encodeJsonChar: encodeJsonChar, + encodeJsonArray: encodeJsonArray, + encodeJsonList: encodeJsonList, + encodeStrMap: encodeStrMap, + encodeMap: encodeMap, + encodeVoid: encodeVoid+};++},{"../Control.Category":47,"../Control.Semigroupoid":92,"../Data.Argonaut.Core":102,"../Data.Either":136,"../Data.Function":149,"../Data.Functor":155,"../Data.Int":165,"../Data.List":194,"../Data.List.Types":193,"../Data.Map":195,"../Data.Maybe":198,"../Data.StrMap":237,"../Data.String":241,"../Data.Tuple":245,"../Data.Unfoldable":247,"../Data.Void":250,"../Prelude":268}],107:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Argonaut_Core = require("../Data.Argonaut.Core");+var Data_Argonaut_Encode_Class = require("../Data.Argonaut.Encode.Class");+var Data_StrMap = require("../Data.StrMap");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var extend = function (dictEncodeJson) {+ return function (v) {+ return function ($6) {+ return Data_Argonaut_Core.foldJsonObject(Data_Argonaut_Core.jsonSingletonObject(v.value0)(v.value1))(function ($7) {+ return Data_Argonaut_Core.fromObject(Data_StrMap.insert(v.value0)(v.value1)($7));+ })(Data_Argonaut_Encode_Class.encodeJson(dictEncodeJson)($6));+ };+ };+};+var assoc = function (dictEncodeJson) {+ return function (k) {+ return function ($8) {+ return Data_Tuple.Tuple.create(k)(Data_Argonaut_Encode_Class.encodeJson(dictEncodeJson)($8));+ };+ };+};+module.exports = {+ assoc: assoc, + extend: extend+};++},{"../Control.Semigroupoid":92,"../Data.Argonaut.Core":102,"../Data.Argonaut.Encode.Class":106,"../Data.StrMap":237,"../Data.Tuple":245,"../Prelude":268}],108:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Argonaut_Encode_Class = require("../Data.Argonaut.Encode.Class");+var Data_Argonaut_Encode_Combinators = require("../Data.Argonaut.Encode.Combinators");+module.exports = {};++},{"../Data.Argonaut.Encode.Class":106,"../Data.Argonaut.Encode.Combinators":107}],109:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Argonaut_Core = require("../Data.Argonaut.Core");+var Data_Argonaut_Decode = require("../Data.Argonaut.Decode");+var Data_Argonaut_Decode_Class = require("../Data.Argonaut.Decode.Class");+var Data_Argonaut_Encode = require("../Data.Argonaut.Encode");+var Data_Argonaut_Encode_Class = require("../Data.Argonaut.Encode.Class");+var Data_Array = require("../Data.Array");+var Data_Either = require("../Data.Either");+var Data_Eq = require("../Data.Eq");+var Data_Foldable = require("../Data.Foldable");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Int = require("../Data.Int");+var Data_List = require("../Data.List");+var Data_List_Types = require("../Data.List.Types");+var Data_Maybe = require("../Data.Maybe");+var Data_Monoid = require("../Data.Monoid");+var Data_Ord = require("../Data.Ord");+var Data_Ordering = require("../Data.Ordering");+var Data_Ring = require("../Data.Ring");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Show = require("../Data.Show");+var Data_StrMap = require("../Data.StrMap");+var Data_Tuple = require("../Data.Tuple");+var Data_Unfoldable = require("../Data.Unfoldable");+var Prelude = require("../Prelude");+var JsonPrim = function (x) {+ return x;+};+var JCursorTop = (function () {+ function JCursorTop() {++ };+ JCursorTop.value = new JCursorTop();+ return JCursorTop;+})();+var JField = (function () {+ function JField(value0, value1) {+ this.value0 = value0;+ this.value1 = value1;+ };+ JField.create = function (value0) {+ return function (value1) {+ return new JField(value0, value1);+ };+ };+ return JField;+})();+var JIndex = (function () {+ function JIndex(value0, value1) {+ this.value0 = value0;+ this.value1 = value1;+ };+ JIndex.create = function (value0) {+ return function (value1) {+ return new JIndex(value0, value1);+ };+ };+ return JIndex;+})();+var showJCursor = new Data_Show.Show(function (v) {+ if (v instanceof JCursorTop) {+ return "JCursorTop";+ };+ if (v instanceof JField) {+ return "(JField " + (Data_Show.show(Data_Show.showString)(v.value0) + (" " + (Data_Show.show(showJCursor)(v.value1) + ")")));+ };+ if (v instanceof JIndex) {+ return "(JIndex " + (Data_Show.show(Data_Show.showInt)(v.value0) + (" " + (Data_Show.show(showJCursor)(v.value1) + ")")));+ };+ throw new Error("Failed pattern match at Data.Argonaut.JCursor line 28, column 3 - line 29, column 3: " + [ v.constructor.name ]);+});+var semigroupJCursor = new Data_Semigroup.Semigroup(function (v) {+ return function (v1) {+ if (v1 instanceof JCursorTop) {+ return v;+ };+ if (v instanceof JCursorTop) {+ return v1;+ };+ if (v instanceof JField) {+ return new JField(v.value0, Data_Semigroup.append(semigroupJCursor)(v.value1)(v1));+ };+ if (v instanceof JIndex) {+ return new JIndex(v.value0, Data_Semigroup.append(semigroupJCursor)(v.value1)(v1));+ };+ throw new Error("Failed pattern match at Data.Argonaut.JCursor line 38, column 3 - line 38, column 26: " + [ v.constructor.name, v1.constructor.name ]);+ };+});+var runJsonPrim = function (v) {+ return v;+};+var showJsonPrim = new Data_Show.Show(function (p) {+ return runJsonPrim(p)(Data_Show.show(Data_Argonaut_Core.showJNull))(Data_Show.show(Data_Show.showBoolean))(Data_Show.show(Data_Show.showNumber))(Data_Show.show(Data_Show.showString));+});+var print = function (v) {+ if (v instanceof JCursorTop) {+ return "";+ };+ if (v instanceof JField) {+ return "." + (v.value0 + Data_Show.show(showJCursor)(v.value1));+ };+ if (v instanceof JIndex) {+ return "[" + (Data_Show.show(Data_Show.showInt)(v.value0) + ("]" + Data_Show.show(showJCursor)(v.value1)));+ };+ throw new Error("Failed pattern match at Data.Argonaut.JCursor line 33, column 1 - line 34, column 1: " + [ v.constructor.name ]);+};+var primToJson = function (p) {+ return runJsonPrim(p)(Data_Argonaut_Core.fromNull)(Data_Argonaut_Core.fromBoolean)(Data_Argonaut_Core.fromNumber)(Data_Argonaut_Core.fromString);+};+var primStr = function (v) {+ return function (v1) {+ return function (v2) {+ return function (v3) {+ return function (f) {+ return f(v);+ };+ };+ };+ };+};+var primNum = function (v) {+ return function (v1) {+ return function (v2) {+ return function (f) {+ return function (v3) {+ return f(v);+ };+ };+ };+ };+};+var primNull = function (f) {+ return function (v) {+ return function (v1) {+ return function (v2) {+ return f(Data_Argonaut_Core.jNull);+ };+ };+ };+};+var primBool = function (v) {+ return function (v1) {+ return function (f) {+ return function (v2) {+ return function (v3) {+ return f(v);+ };+ };+ };+ };+};+var toPrims = (function () {+ var objFn = function (obj) {+ var f = function (v) {+ return Data_Functor.map(Data_List_Types.functorList)(function (t) {+ return new Data_Tuple.Tuple(new JField(v.value0, Data_Tuple.fst(t)), Data_Tuple.snd(t));+ })(toPrims(v.value1));+ };+ return Control_Bind.bind(Data_List_Types.bindList)(Data_StrMap.toUnfoldable(Data_List_Types.unfoldableList)(obj))(f);+ };+ var mkTop = function (p) {+ return Data_List.singleton(new Data_Tuple.Tuple(JCursorTop.value, p));+ };+ var nullFn = function (v) {+ return mkTop(primNull);+ };+ var numFn = function (n) {+ return mkTop(primNum(n));+ };+ var strFn = function (s) {+ return mkTop(primStr(s));+ };+ var boolFn = function (b) {+ return mkTop(primBool(b));+ };+ var arrFn$prime = function (v) {+ return Data_List.fromFoldable(Data_List_Types.foldableList)(Data_Functor.map(Data_List_Types.functorList)(function (t) {+ return new Data_Tuple.Tuple(new JIndex(v.value0, Data_Tuple.fst(t)), Data_Tuple.snd(t));+ })(toPrims(v.value1)));+ };+ var arrFn = function (arr) {+ var zipped = Data_List.zipWith(Data_Tuple.Tuple.create)(Data_List.range(0)(Data_Array.length(arr) - 1 | 0))(Data_List.fromFoldable(Data_Foldable.foldableArray)(arr));+ return Control_Bind.bind(Data_List_Types.bindList)(zipped)(arrFn$prime);+ };+ return Data_Argonaut_Core.foldJson(nullFn)(boolFn)(numFn)(strFn)(arrFn)(objFn);+})();+var monoidJCursor = new Data_Monoid.Monoid(function () {+ return semigroupJCursor;+}, JCursorTop.value);+var inferEmpty = function (v) {+ if (v instanceof JCursorTop) {+ return Data_Argonaut_Core.jsonNull;+ };+ if (v instanceof JField) {+ return Data_Argonaut_Core.jsonEmptyObject;+ };+ if (v instanceof JIndex) {+ return Data_Argonaut_Core.jsonEmptyArray;+ };+ throw new Error("Failed pattern match at Data.Argonaut.JCursor line 98, column 1 - line 98, column 37: " + [ v.constructor.name ]);+};+var fail = function (dictShow) {+ return function (x) {+ return Data_Either.Left.create("Expected String or Number but found: " + Data_Show.show(dictShow)(x));+ };+};+var eqJCursor = new Data_Eq.Eq(function (x) {+ return function (y) {+ if (x instanceof JCursorTop && y instanceof JCursorTop) {+ return true;+ };+ if (x instanceof JField && y instanceof JField) {+ return x.value0 === y.value0 && Data_Eq.eq(eqJCursor)(x.value1)(y.value1);+ };+ if (x instanceof JIndex && y instanceof JIndex) {+ return x.value0 === y.value0 && Data_Eq.eq(eqJCursor)(x.value1)(y.value1);+ };+ return false;+ };+});+var ordJCursor = new Data_Ord.Ord(function () {+ return eqJCursor;+}, function (x) {+ return function (y) {+ if (x instanceof JCursorTop && y instanceof JCursorTop) {+ return Data_Ordering.EQ.value;+ };+ if (x instanceof JCursorTop) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof JCursorTop) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof JField && y instanceof JField) {+ var v = Data_Ord.compare(Data_Ord.ordString)(x.value0)(y.value0);+ if (v instanceof Data_Ordering.LT) {+ return Data_Ordering.LT.value;+ };+ if (v instanceof Data_Ordering.GT) {+ return Data_Ordering.GT.value;+ };+ return Data_Ord.compare(ordJCursor)(x.value1)(y.value1);+ };+ if (x instanceof JField) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof JField) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof JIndex && y instanceof JIndex) {+ var v = Data_Ord.compare(Data_Ord.ordInt)(x.value0)(y.value0);+ if (v instanceof Data_Ordering.LT) {+ return Data_Ordering.LT.value;+ };+ if (v instanceof Data_Ordering.GT) {+ return Data_Ordering.GT.value;+ };+ return Data_Ord.compare(ordJCursor)(x.value1)(y.value1);+ };+ throw new Error("Failed pattern match: " + [ x.constructor.name, y.constructor.name ]);+ };+});+var encodeJsonJCursor = new Data_Argonaut_Encode_Class.EncodeJson((function () {+ var loop = function (v) {+ if (v instanceof JCursorTop) {+ return [ ];+ };+ if (v instanceof JField) {+ return Data_Semigroup.append(Data_Semigroup.semigroupArray)([ Data_Argonaut_Encode_Class.encodeJson(Data_Argonaut_Encode_Class.encodeJsonJString)(v.value0) ])(loop(v.value1));+ };+ if (v instanceof JIndex) {+ return Data_Semigroup.append(Data_Semigroup.semigroupArray)([ Data_Argonaut_Encode_Class.encodeJson(Data_Argonaut_Encode_Class.encodeJsonInt)(v.value0) ])(loop(v.value1));+ };+ throw new Error("Failed pattern match at Data.Argonaut.JCursor line 47, column 16 - line 50, column 49: " + [ v.constructor.name ]);+ };+ return function ($151) {+ return Data_Argonaut_Encode_Class.encodeJson(Data_Argonaut_Encode_Class.encodeJsonArray(Data_Argonaut_Encode_Class.encodeJsonJson))(loop($151));+ };+})());+var downIndex = function (i) {+ var downIndex$prime = function (v) {+ if (v instanceof JCursorTop) {+ return new JIndex(i, JCursorTop.value);+ };+ if (v instanceof JField) {+ return new JField(v.value0, downIndex$prime(v.value1));+ };+ if (v instanceof JIndex) {+ return new JIndex(v.value0, downIndex$prime(v.value1));+ };+ throw new Error("Failed pattern match at Data.Argonaut.JCursor line 87, column 15 - line 90, column 54: " + [ v.constructor.name ]);+ };+ return downIndex$prime;+};+var downField = function (i) {+ var downField$prime = function (v) {+ if (v instanceof JCursorTop) {+ return new JField(i, JCursorTop.value);+ };+ if (v instanceof JField) {+ return new JField(v.value0, downField$prime(v.value1));+ };+ if (v instanceof JIndex) {+ return new JIndex(v.value0, downField$prime(v.value1));+ };+ throw new Error("Failed pattern match at Data.Argonaut.JCursor line 81, column 15 - line 84, column 54: " + [ v.constructor.name ]);+ };+ return downField$prime;+};+var insideOut = function (v) {+ if (v instanceof JCursorTop) {+ return JCursorTop.value;+ };+ if (v instanceof JField) {+ return downField(v.value0)(insideOut(v.value1));+ };+ if (v instanceof JIndex) {+ return downIndex(v.value0)(insideOut(v.value1));+ };+ throw new Error("Failed pattern match at Data.Argonaut.JCursor line 76, column 1 - line 76, column 34: " + [ v.constructor.name ]);+};+var decodeJsonJCursor = new Data_Argonaut_Decode_Class.DecodeJson(function (j) {+ var goNum = function (c) {+ return function ($152) {+ return Data_Maybe.maybe(new Data_Either.Left("Not an Int"))(function ($153) {+ return Data_Either.Right.create(Data_Function.flip(JIndex.create)(c)($153));+ })(Data_Int.fromNumber($152));+ };+ };+ var loop = function (arr) {+ return Data_Maybe.maybe(new Data_Either.Right(JCursorTop.value))(goLoop)(Control_Apply.apply(Data_Maybe.applyMaybe)(Data_Functor.map(Data_Maybe.functorMaybe)(Data_Tuple.Tuple.create)(Data_Array.head(arr)))(Data_Array.tail(arr)));+ };+ var goLoop = function (v) {+ return Control_Bind.bind(Data_Either.bindEither)(loop(v.value1))(function (v1) {+ return Data_Argonaut_Core.foldJson(fail(Data_Argonaut_Core.showJNull))(fail(Data_Show.showBoolean))(goNum(v1))(function ($154) {+ return Data_Either.Right.create(Data_Function.flip(JField.create)(v1)($154));+ })(fail(Data_Show.showArray(Data_Argonaut_Core.showJson)))(fail(Data_StrMap.showStrMap(Data_Argonaut_Core.showJson)))(v.value0);+ });+ };+ return Control_Bind.bind(Data_Either.bindEither)(Data_Argonaut_Decode_Class.decodeJson(Data_Argonaut_Decode_Class.decodeArray(Data_Argonaut_Decode_Class.decodeJsonJson))(j))(loop);+});+var cursorSet = function (v) {+ return function (v1) {+ if (v instanceof JCursorTop) {+ return function ($155) {+ return Control_Applicative.pure(Data_Maybe.applicativeMaybe)(Data_Function["const"](v1)($155));+ };+ };+ if (v instanceof JField) {+ var mergeObjs = function (m) {+ return Data_Functor.map(Data_Maybe.functorMaybe)(function ($156) {+ return Data_Argonaut_Core.fromObject(Data_Function.flip(Data_StrMap.insert(v.value0))(m)($156));+ })(cursorSet(v.value1)(v1)(Data_Maybe.fromMaybe(inferEmpty(v.value1))(Data_StrMap.lookup(v.value0)(m))));+ };+ var defaultObj = Data_Functor.map(Data_Maybe.functorMaybe)(function ($157) {+ return Data_Argonaut_Core.fromObject(Data_StrMap.singleton(v.value0)($157));+ })(cursorSet(v.value1)(v1)(inferEmpty(v.value1)));+ return Data_Argonaut_Core.foldJsonObject(defaultObj)(mergeObjs);+ };+ if (v instanceof JIndex) {+ var setArr = function (__copy_xs) {+ return function (__copy_i$prime) {+ return function (__copy_v$prime) {+ var xs = __copy_xs;+ var i$prime = __copy_i$prime;+ var v$prime = __copy_v$prime;+ var __tco_done = false;+ var __tco_result;+ var __tco_xs;+ var __tco_i$prime;+ var __tco_v$prime;+ function __tco_loop(xs, i$prime, v$prime) {+ var len = Data_Array.length(xs);+ var $138 = i$prime < 0;+ if ($138) {+ __tco_done = true;+ return Data_Maybe.Nothing.value;+ };+ var $139 = i$prime >= len;+ if ($139) {+ __tco_xs = Data_Semigroup.append(Data_Semigroup.semigroupArray)(xs)(Data_Unfoldable.replicate(Data_Unfoldable.unfoldableArray)((i$prime - len | 0) + 1 | 0)(Data_Argonaut_Core.jsonNull));+ __tco_i$prime = i$prime;+ __tco_v$prime = v$prime;+ return;+ };+ __tco_done = true;+ return Data_Functor.map(Data_Maybe.functorMaybe)(Data_Argonaut_Core.fromArray)(Data_Array.updateAt(i$prime)(v$prime)(xs));+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(xs, i$prime, v$prime);+ xs = __tco_xs;+ i$prime = __tco_i$prime;+ v$prime = __tco_v$prime;+ };+ return __tco_result;+ };+ };+ };+ var mergeArrs = function (a) {+ return Control_Bind.bindFlipped(Data_Maybe.bindMaybe)(setArr(a)(v.value0))(cursorSet(v.value1)(v1)(Data_Maybe.fromMaybe(inferEmpty(v.value1))(Data_Array.index(a)(v.value0))));+ };+ var defaultArr = Data_Functor.map(Data_Maybe.functorMaybe)(Data_Argonaut_Core.fromArray)(Control_Bind.bindFlipped(Data_Maybe.bindMaybe)(Data_Function.flip(Data_Array.updateAt(v.value0))(Data_Unfoldable.replicate(Data_Unfoldable.unfoldableArray)(v.value0 + 1 | 0)(Data_Argonaut_Core.jsonNull)))(cursorSet(v.value1)(v1)(inferEmpty(v.value1))));+ return Data_Argonaut_Core.foldJsonArray(defaultArr)(mergeArrs);+ };+ throw new Error("Failed pattern match at Data.Argonaut.JCursor line 103, column 1 - line 103, column 42: " + [ v.constructor.name, v1.constructor.name ]);+ };+};+var fromPrims = function (lst) {+ var f = function (j) {+ return function (v) {+ return Control_Bind.bind(Data_Maybe.bindMaybe)(j)(cursorSet(v.value0)(primToJson(v.value1)));+ };+ };+ return Data_Foldable.foldl(Data_List_Types.foldableList)(f)(Data_Functor.map(Data_Maybe.functorMaybe)(function ($158) {+ return inferEmpty(Data_Tuple.fst($158));+ })(Data_List.head(lst)))(lst);+};+var cursorGet = function (v) {+ if (v instanceof JCursorTop) {+ return Data_Maybe.Just.create;+ };+ if (v instanceof JField) {+ return Data_Argonaut_Core.foldJsonObject(Data_Maybe.Nothing.value)(Control_Bind.composeKleisliFlipped(Data_Maybe.bindMaybe)(cursorGet(v.value1))(Data_StrMap.lookup(v.value0)));+ };+ if (v instanceof JIndex) {+ return Data_Argonaut_Core.foldJsonArray(Data_Maybe.Nothing.value)(Control_Bind.composeKleisliFlipped(Data_Maybe.bindMaybe)(cursorGet(v.value1))(function (v1) {+ return Data_Array.index(v1)(v.value0);+ }));+ };+ throw new Error("Failed pattern match at Data.Argonaut.JCursor line 93, column 1 - line 93, column 28: " + [ v.constructor.name ]);+};+module.exports = {+ JCursorTop: JCursorTop, + JField: JField, + JIndex: JIndex, + JsonPrim: JsonPrim, + cursorGet: cursorGet, + cursorSet: cursorSet, + downField: downField, + downIndex: downIndex, + fail: fail, + fromPrims: fromPrims, + inferEmpty: inferEmpty, + insideOut: insideOut, + primBool: primBool, + primNull: primNull, + primNum: primNum, + primStr: primStr, + primToJson: primToJson, + print: print, + runJsonPrim: runJsonPrim, + toPrims: toPrims, + eqJCursor: eqJCursor, + ordJCursor: ordJCursor, + showJCursor: showJCursor, + semigroupJCursor: semigroupJCursor, + monoidJCursor: monoidJCursor, + encodeJsonJCursor: encodeJsonJCursor, + showJsonPrim: showJsonPrim, + decodeJsonJCursor: decodeJsonJCursor+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Semigroupoid":92,"../Data.Argonaut.Core":102,"../Data.Argonaut.Decode":105,"../Data.Argonaut.Decode.Class":103,"../Data.Argonaut.Encode":108,"../Data.Argonaut.Encode.Class":106,"../Data.Array":119,"../Data.Either":136,"../Data.Eq":138,"../Data.Foldable":143,"../Data.Function":149,"../Data.Functor":155,"../Data.HeytingAlgebra":160,"../Data.Int":165,"../Data.List":194,"../Data.List.Types":193,"../Data.Maybe":198,"../Data.Monoid":207,"../Data.Ord":216,"../Data.Ordering":217,"../Data.Ring":227,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Show":233,"../Data.StrMap":237,"../Data.Tuple":245,"../Data.Unfoldable":247,"../Prelude":268}],110:[function(require,module,exports){+"use strict";++exports._jsonParser = function (fail, succ, s) {+ try {+ return succ(JSON.parse(s));+ }+ catch (e) {+ return fail(e.message);+ }+};++},{}],111:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Data_Argonaut_Core = require("../Data.Argonaut.Core");+var Data_Either = require("../Data.Either");+var Data_Function_Uncurried = require("../Data.Function.Uncurried");+var jsonParser = function (j) {+ return $foreign._jsonParser(Data_Either.Left.create, Data_Either.Right.create, j);+};+module.exports = {+ jsonParser: jsonParser+};++},{"../Data.Argonaut.Core":102,"../Data.Either":136,"../Data.Function.Uncurried":148,"./foreign":110}],112:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Argonaut_Core = require("../Data.Argonaut.Core");+var Data_Lens = require("../Data.Lens");+var Data_Lens_Prism = require("../Data.Lens.Prism");+var _String = function (dictChoice) {+ return Data_Lens_Prism["prism'"](Data_Argonaut_Core.fromString)(Data_Argonaut_Core.toString)(dictChoice);+};+var _Object = function (dictChoice) {+ return Data_Lens_Prism["prism'"](Data_Argonaut_Core.fromObject)(Data_Argonaut_Core.toObject)(dictChoice);+};+var _Number = function (dictChoice) {+ return Data_Lens_Prism["prism'"](Data_Argonaut_Core.fromNumber)(Data_Argonaut_Core.toNumber)(dictChoice);+};+var _Null = function (dictChoice) {+ return Data_Lens_Prism["prism'"](Data_Argonaut_Core.fromNull)(Data_Argonaut_Core.toNull)(dictChoice);+};+var _Boolean = function (dictChoice) {+ return Data_Lens_Prism["prism'"](Data_Argonaut_Core.fromBoolean)(Data_Argonaut_Core.toBoolean)(dictChoice);+};+var _Array = function (dictChoice) {+ return Data_Lens_Prism["prism'"](Data_Argonaut_Core.fromArray)(Data_Argonaut_Core.toArray)(dictChoice);+};+module.exports = {+ _Array: _Array, + _Boolean: _Boolean, + _Null: _Null, + _Number: _Number, + _Object: _Object, + _String: _String+};++},{"../Data.Argonaut.Core":102,"../Data.Lens":191,"../Data.Lens.Prism":187}],113:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Argonaut_Core = require("../Data.Argonaut.Core");+var Data_Lens = require("../Data.Lens");+var Data_Lens_Fold = require("../Data.Lens.Fold");+var Prelude = require("../Prelude");+var _JsonString = function (dictWander) {+ return function ($6) {+ return Control_Category.id(Control_Category.categoryFn)(Data_Lens_Fold.filtered(dictWander.Choice1())(Data_Argonaut_Core.isString)($6));+ };+};+var _JsonObject = function (dictWander) {+ return function ($7) {+ return Control_Category.id(Control_Category.categoryFn)(Data_Lens_Fold.filtered(dictWander.Choice1())(Data_Argonaut_Core.isObject)($7));+ };+};+var _JsonNumber = function (dictWander) {+ return function ($8) {+ return Control_Category.id(Control_Category.categoryFn)(Data_Lens_Fold.filtered(dictWander.Choice1())(Data_Argonaut_Core.isNumber)($8));+ };+};+var _JsonNull = function (dictWander) {+ return function ($9) {+ return Control_Category.id(Control_Category.categoryFn)(Data_Lens_Fold.filtered(dictWander.Choice1())(Data_Argonaut_Core.isNull)($9));+ };+};+var _JsonBoolean = function (dictWander) {+ return function ($10) {+ return Control_Category.id(Control_Category.categoryFn)(Data_Lens_Fold.filtered(dictWander.Choice1())(Data_Argonaut_Core.isBoolean)($10));+ };+};+var _JsonArray = function (dictWander) {+ return function ($11) {+ return Control_Category.id(Control_Category.categoryFn)(Data_Lens_Fold.filtered(dictWander.Choice1())(Data_Argonaut_Core.isArray)($11));+ };+};+module.exports = {+ _JsonArray: _JsonArray, + _JsonBoolean: _JsonBoolean, + _JsonNull: _JsonNull, + _JsonNumber: _JsonNumber, + _JsonObject: _JsonObject, + _JsonString: _JsonString+};++},{"../Control.Category":47,"../Control.Semigroupoid":92,"../Data.Argonaut.Core":102,"../Data.Lens":191,"../Data.Lens.Fold":167,"../Prelude":268}],114:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Argonaut_Core = require("../Data.Argonaut.Core");+var Data_Argonaut_Decode = require("../Data.Argonaut.Decode");+var Data_Argonaut_Encode = require("../Data.Argonaut.Encode");+var Data_Argonaut_JCursor = require("../Data.Argonaut.JCursor");+var Data_Argonaut_Parser = require("../Data.Argonaut.Parser");+var Data_Argonaut_Prisms = require("../Data.Argonaut.Prisms");+var Data_Argonaut_Traversals = require("../Data.Argonaut.Traversals");+module.exports = {};++},{"../Data.Argonaut.Core":102,"../Data.Argonaut.Decode":105,"../Data.Argonaut.Encode":108,"../Data.Argonaut.JCursor":109,"../Data.Argonaut.Parser":111,"../Data.Argonaut.Prisms":112,"../Data.Argonaut.Traversals":113}],115:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Bind = require("../Control.Bind");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var Control_Monad_ST = require("../Control.Monad.ST");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Array_ST = require("../Data.Array.ST");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Maybe = require("../Data.Maybe");+var Data_Semiring = require("../Data.Semiring");+var Prelude = require("../Prelude");+var Iterator = (function () {+ function Iterator(value0, value1) {+ this.value0 = value0;+ this.value1 = value1;+ };+ Iterator.create = function (value0) {+ return function (value1) {+ return new Iterator(value0, value1);+ };+ };+ return Iterator;+})();+var peek = function (v) {+ return function __do() {+ var v1 = Control_Monad_ST.readSTRef(v.value1)();+ return v.value0(v1);+ };+};+var next = function (v) {+ return function __do() {+ var v1 = Control_Monad_ST.readSTRef(v.value1)();+ var v2 = Control_Monad_ST.modifySTRef(v.value1)(function (v2) {+ return v2 + 1 | 0;+ })();+ return v.value0(v1);+ };+};+var pushWhile = function (p) {+ return function (iter) {+ return function (array) {+ return function __do() {+ var v = Control_Monad_ST.newSTRef(false)();+ while (Data_Functor.map(Control_Monad_Eff.functorEff)(Data_HeytingAlgebra.not(Data_HeytingAlgebra.heytingAlgebraBoolean))(Control_Monad_ST.readSTRef(v))()) {+ (function __do() {+ var v1 = peek(iter)();+ if (v1 instanceof Data_Maybe.Just && p(v1.value0)) {+ var v2 = Data_Array_ST.pushSTArray(array)(v1.value0)();+ return Data_Functor["void"](Control_Monad_Eff.functorEff)(next(iter))();+ };+ return Data_Functor["void"](Control_Monad_Eff.functorEff)(Control_Monad_ST.writeSTRef(v)(true))();+ })();+ };+ return {};+ };+ };+ };+};+var pushAll = pushWhile(Data_Function["const"](true));+var iterator = function (f) {+ return Data_Functor.map(Control_Monad_Eff.functorEff)(Iterator.create(f))(Control_Monad_ST.newSTRef(0));+};+var iterate = function (iter) {+ return function (f) {+ return function __do() {+ var v = Control_Monad_ST.newSTRef(false)();+ while (Data_Functor.map(Control_Monad_Eff.functorEff)(Data_HeytingAlgebra.not(Data_HeytingAlgebra.heytingAlgebraBoolean))(Control_Monad_ST.readSTRef(v))()) {+ (function __do() {+ var v1 = next(iter)();+ if (v1 instanceof Data_Maybe.Just) {+ return f(v1.value0)();+ };+ if (v1 instanceof Data_Maybe.Nothing) {+ return Data_Functor["void"](Control_Monad_Eff.functorEff)(Control_Monad_ST.writeSTRef(v)(true))();+ };+ throw new Error("Failed pattern match at Data.Array.ST.Iterator line 39, column 5 - line 41, column 46: " + [ v1.constructor.name ]);+ })();+ };+ return {};+ };+ };+};+var exhausted = function ($27) {+ return Data_Functor.map(Control_Monad_Eff.functorEff)(Data_Maybe.isNothing)(peek($27));+};+module.exports = {+ exhausted: exhausted, + iterate: iterate, + iterator: iterator, + next: next, + peek: peek, + pushAll: pushAll, + pushWhile: pushWhile+};++},{"../Control.Applicative":40,"../Control.Bind":46,"../Control.Monad.Eff":70,"../Control.Monad.ST":79,"../Control.Semigroupoid":92,"../Data.Array.ST":117,"../Data.Function":149,"../Data.Functor":155,"../Data.HeytingAlgebra":160,"../Data.Maybe":198,"../Data.Semiring":231,"../Prelude":268}],116:[function(require,module,exports){+"use strict";++exports.runSTArray = function (f) {+ return f;+};++exports.emptySTArray = function () {+ return [];+};++exports.peekSTArrayImpl = function (just) {+ return function (nothing) {+ return function (xs) {+ return function (i) {+ return function () {+ return i >= 0 && i < xs.length ? just(xs[i]) : nothing;+ };+ };+ };+ };+};++exports.pokeSTArray = function (xs) {+ return function (i) {+ return function (a) {+ return function () {+ var ret = i >= 0 && i < xs.length;+ if (ret) xs[i] = a;+ return ret;+ };+ };+ };+};++exports.pushAllSTArray = function (xs) {+ return function (as) {+ return function () {+ return xs.push.apply(xs, as);+ };+ };+};++exports.spliceSTArray = function (xs) {+ return function (i) {+ return function (howMany) {+ return function (bs) {+ return function () {+ return xs.splice.apply(xs, [i, howMany].concat(bs));+ };+ };+ };+ };+};++exports.copyImpl = function (xs) {+ return function () {+ return xs.slice();+ };+};++exports.toAssocArray = function (xs) {+ return function () {+ var n = xs.length;+ var as = new Array(n);+ for (var i = 0; i < n; i++) as[i] = { value: xs[i], index: i };+ return as;+ };+};++},{}],117:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Applicative = require("../Control.Applicative");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var Control_Monad_ST = require("../Control.Monad.ST");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Maybe = require("../Data.Maybe");+var Prelude = require("../Prelude");+var Unsafe_Coerce = require("../Unsafe.Coerce");+var unsafeFreeze = function ($0) {+ return Control_Applicative.pure(Control_Monad_Eff.applicativeEff)(Unsafe_Coerce.unsafeCoerce($0));+};+var thaw = $foreign.copyImpl;+var pushSTArray = function (arr) {+ return function (a) {+ return $foreign.pushAllSTArray(arr)([ a ]);+ };+};+var peekSTArray = $foreign.peekSTArrayImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+var freeze = $foreign.copyImpl;+module.exports = {+ freeze: freeze, + peekSTArray: peekSTArray, + pushSTArray: pushSTArray, + thaw: thaw, + unsafeFreeze: unsafeFreeze, + emptySTArray: $foreign.emptySTArray, + pokeSTArray: $foreign.pokeSTArray, + pushAllSTArray: $foreign.pushAllSTArray, + runSTArray: $foreign.runSTArray, + spliceSTArray: $foreign.spliceSTArray, + toAssocArray: $foreign.toAssocArray+};++},{"../Control.Applicative":40,"../Control.Monad.Eff":70,"../Control.Monad.ST":79,"../Control.Semigroupoid":92,"../Data.Maybe":198,"../Prelude":268,"../Unsafe.Coerce":271,"./foreign":116}],118:[function(require,module,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;+ };+};++var replicate = function (count) {+ return function (value) {+ if (count < 1) {+ return [];+ }+ var result = new Array(count);+ return result.fill(value);+ };+};++var replicatePolyfill = function (count) {+ return function (value) {+ var result = [];+ var n = 0;+ for (var i = 0; i < count; i++) {+ result[n++] = value;+ }+ return result;+ };+};++// In browsers that have Array.prototype.fill we use it, as it's faster.+exports.replicate = typeof Array.prototype.fill === "function" ?+ replicate :+ replicatePolyfill;++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;+};++//------------------------------------------------------------------------------+// Extending arrays ------------------------------------------------------------+//------------------------------------------------------------------------------++exports.cons = function (e) {+ return function (l) {+ return [e].concat(l);+ };+};++exports.snoc = function (l) {+ return function (e) {+ var l1 = l.slice();+ l1.push(e);+ return l1;+ };+};++//------------------------------------------------------------------------------+// Non-indexed reads -----------------------------------------------------------+//------------------------------------------------------------------------------++exports["uncons'"] = function (empty) {+ return function (next) {+ return function (xs) {+ return xs.length === 0 ? empty({}) : next(xs[0])(xs.slice(1));+ };+ };+};++//------------------------------------------------------------------------------+// Indexed operations ----------------------------------------------------------+//------------------------------------------------------------------------------++exports.indexImpl = function (just) {+ return function (nothing) {+ return function (xs) {+ return function (i) {+ return i < 0 || i >= xs.length ? nothing : just(xs[i]);+ };+ };+ };+};++exports.findIndexImpl = function (just) {+ return function (nothing) {+ return function (f) {+ return function (xs) {+ for (var i = 0, l = xs.length; i < l; i++) {+ if (f(xs[i])) return just(i);+ }+ return nothing;+ };+ };+ };+};++exports.findLastIndexImpl = function (just) {+ return function (nothing) {+ return function (f) {+ return function (xs) {+ for (var i = xs.length - 1; i >= 0; i--) {+ if (f(xs[i])) return just(i);+ }+ return nothing;+ };+ };+ };+};++exports._insertAt = function (just) {+ return function (nothing) {+ return function (i) {+ return function (a) {+ return function (l) {+ if (i < 0 || i > l.length) return nothing;+ var l1 = l.slice();+ l1.splice(i, 0, a);+ return just(l1);+ };+ };+ };+ };+};++exports._deleteAt = function (just) {+ return function (nothing) {+ return function (i) {+ return function (l) {+ if (i < 0 || i >= l.length) return nothing;+ var l1 = l.slice();+ l1.splice(i, 1);+ return just(l1);+ };+ };+ };+};++exports._updateAt = function (just) {+ return function (nothing) {+ return function (i) {+ return function (a) {+ return function (l) {+ if (i < 0 || i >= l.length) return nothing;+ var l1 = l.slice();+ l1[i] = a;+ return just(l1);+ };+ };+ };+ };+};++//------------------------------------------------------------------------------+// Transformations -------------------------------------------------------------+//------------------------------------------------------------------------------++exports.reverse = function (l) {+ return l.slice().reverse();+};++exports.concat = function (xss) {+ if (xss.length <= 10000) {+ // This method is faster, but it crashes on big arrays.+ // So we use it when can and fallback to simple variant otherwise.+ return Array.prototype.concat.apply([], xss);+ }++ var result = [];+ for (var i = 0, l = xss.length; i < l; i++) {+ var xs = xss[i];+ for (var j = 0, m = xs.length; j < m; j++) {+ result.push(xs[j]);+ }+ }+ return result;+};++exports.filter = function (f) {+ return function (xs) {+ return xs.filter(f);+ };+};++exports.partition = function (f) {+ return function (xs) {+ var yes = [];+ var no = [];+ for (var i = 0; i < xs.length; i++) {+ var x = xs[i];+ if (f(x))+ yes.push(x);+ else+ no.push(x);+ }+ return { yes: yes, no: no };+ };+};++//------------------------------------------------------------------------------+// Sorting ---------------------------------------------------------------------+//------------------------------------------------------------------------------++exports.sortImpl = function (f) {+ return function (l) {+ // jshint maxparams: 2+ return l.slice().sort(function (x, y) {+ return f(x)(y);+ });+ };+};++//------------------------------------------------------------------------------+// Subarrays -------------------------------------------------------------------+//------------------------------------------------------------------------------++exports.slice = function (s) {+ return function (e) {+ return function (l) {+ return l.slice(s, e);+ };+ };+};++exports.take = function (n) {+ return function (l) {+ return n < 1 ? [] : l.slice(0, n);+ };+};++exports.drop = function (n) {+ return function (l) {+ return n < 1 ? l : l.slice(n);+ };+};++//------------------------------------------------------------------------------+// 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;+ };+ };+};++//------------------------------------------------------------------------------+// Partial ---------------------------------------------------------------------+//------------------------------------------------------------------------------++exports.unsafeIndexImpl = function (xs) {+ return function (n) {+ return xs[n];+ };+};++},{}],119:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Alt = require("../Control.Alt");+var Control_Alternative = require("../Control.Alternative");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Category = require("../Control.Category");+var Control_Lazy = require("../Control.Lazy");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var Control_Monad_Rec_Class = require("../Control.Monad.Rec.Class");+var Control_Monad_ST = require("../Control.Monad.ST");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Array_ST = require("../Data.Array.ST");+var Data_Array_ST_Iterator = require("../Data.Array.ST.Iterator");+var Data_Boolean = require("../Data.Boolean");+var Data_Eq = require("../Data.Eq");+var Data_Foldable = require("../Data.Foldable");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Maybe = require("../Data.Maybe");+var Data_NonEmpty = require("../Data.NonEmpty");+var Data_Ord = require("../Data.Ord");+var Data_Ordering = require("../Data.Ordering");+var Data_Ring = require("../Data.Ring");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Traversable = require("../Data.Traversable");+var Data_Tuple = require("../Data.Tuple");+var Data_Unfoldable = require("../Data.Unfoldable");+var Partial_Unsafe = require("../Partial.Unsafe");+var Prelude = require("../Prelude");+var zipWithA = function (dictApplicative) {+ return function (f) {+ return function (xs) {+ return function (ys) {+ return Data_Traversable.sequence(Data_Traversable.traversableArray)(dictApplicative)($foreign.zipWith(f)(xs)(ys));+ };+ };+ };+};+var zip = $foreign.zipWith(Data_Tuple.Tuple.create);+var updateAt = $foreign._updateAt(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+var unzip = $foreign["uncons'"](function (v) {+ return new Data_Tuple.Tuple([ ], [ ]);+})(function (v) {+ return function (ts) {+ var v1 = unzip(ts);+ return new Data_Tuple.Tuple($foreign.cons(v.value0)(v1.value0), $foreign.cons(v.value1)(v1.value1));+ };+});+var unsafeIndex = function (dictPartial) {+ return $foreign.unsafeIndexImpl;+};+var uncons = $foreign["uncons'"](Data_Function["const"](Data_Maybe.Nothing.value))(function (x) {+ return function (xs) {+ return new Data_Maybe.Just({+ head: x, + tail: xs+ });+ };+});+var toUnfoldable = function (dictUnfoldable) {+ return function (xs) {+ var len = $foreign.length(xs);+ var f = function (i) {+ if (i < len) {+ return new Data_Maybe.Just(new Data_Tuple.Tuple(unsafeIndex()(xs)(i), i + 1 | 0));+ };+ if (Data_Boolean.otherwise) {+ return Data_Maybe.Nothing.value;+ };+ throw new Error("Failed pattern match at Data.Array line 132, column 19 - line 137, column 26: " + [ i.constructor.name ]);+ };+ return Data_Unfoldable.unfoldr(dictUnfoldable)(f)(0);+ };+};+var tail = $foreign["uncons'"](Data_Function["const"](Data_Maybe.Nothing.value))(function (v) {+ return function (xs) {+ return new Data_Maybe.Just(xs);+ };+});+var sortBy = function (comp) {+ return function (xs) {+ var comp$prime = function (x) {+ return function (y) {+ var v = comp(x)(y);+ if (v instanceof Data_Ordering.GT) {+ return 1;+ };+ if (v instanceof Data_Ordering.EQ) {+ return 0;+ };+ if (v instanceof Data_Ordering.LT) {+ return -1 | 0;+ };+ throw new Error("Failed pattern match at Data.Array line 462, column 15 - line 467, column 1: " + [ v.constructor.name ]);+ };+ };+ return $foreign.sortImpl(comp$prime)(xs);+ };+};+var sortWith = function (dictOrd) {+ return function (f) {+ return sortBy(Data_Ord.comparing(dictOrd)(f));+ };+};+var sort = function (dictOrd) {+ return function (xs) {+ return sortBy(Data_Ord.compare(dictOrd))(xs);+ };+};+var singleton = function (a) {+ return [ a ];+};+var $$null = function (xs) {+ return $foreign.length(xs) === 0;+};+var nubBy = function (eq) {+ return function (xs) {+ var v = uncons(xs);+ if (v instanceof Data_Maybe.Just) {+ return $foreign.cons(v.value0.head)(nubBy(eq)($foreign.filter(function (y) {+ return !eq(v.value0.head)(y);+ })(v.value0.tail)));+ };+ if (v instanceof Data_Maybe.Nothing) {+ return [ ];+ };+ throw new Error("Failed pattern match at Data.Array line 570, column 3 - line 572, column 18: " + [ v.constructor.name ]);+ };+};+var nub = function (dictEq) {+ return nubBy(Data_Eq.eq(dictEq));+};+var mapWithIndex = function (f) {+ return function (xs) {+ return $foreign.zipWith(f)($foreign.range(0)($foreign.length(xs) - 1 | 0))(xs);+ };+};+var some = function (dictAlternative) {+ return function (dictLazy) {+ return function (v) {+ return Control_Apply.apply((dictAlternative.Applicative0()).Apply0())(Data_Functor.map(((dictAlternative.Plus1()).Alt0()).Functor0())($foreign.cons)(v))(Control_Lazy.defer(dictLazy)(function (v1) {+ return many(dictAlternative)(dictLazy)(v);+ }));+ };+ };+};+var many = function (dictAlternative) {+ return function (dictLazy) {+ return function (v) {+ return Control_Alt.alt((dictAlternative.Plus1()).Alt0())(some(dictAlternative)(dictLazy)(v))(Control_Applicative.pure(dictAlternative.Applicative0())([ ]));+ };+ };+};+var insertAt = $foreign._insertAt(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+var init = function (xs) {+ if ($$null(xs)) {+ return Data_Maybe.Nothing.value;+ };+ if (Data_Boolean.otherwise) {+ return new Data_Maybe.Just($foreign.slice(0)($foreign.length(xs) - 1 | 0)(xs));+ };+ throw new Error("Failed pattern match at Data.Array line 248, column 1 - line 250, column 55: " + [ xs.constructor.name ]);+};+var index = $foreign.indexImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+var last = function (xs) {+ return index(xs)($foreign.length(xs) - 1 | 0);+};+var unsnoc = function (xs) {+ return Control_Apply.apply(Data_Maybe.applyMaybe)(Data_Functor.map(Data_Maybe.functorMaybe)(function (v) {+ return function (v1) {+ return {+ init: v, + last: v1+ };+ };+ })(init(xs)))(last(xs));+};+var modifyAt = function (i) {+ return function (f) {+ return function (xs) {+ var go = function (x) {+ return updateAt(i)(f(x))(xs);+ };+ return Data_Maybe.maybe(Data_Maybe.Nothing.value)(go)(index(xs)(i));+ };+ };+};+var span = function (p) {+ return function (arr) {+ var go = function (__copy_i) {+ var i = __copy_i;+ var __tco_done = false;+ var __tco_result;+ var __tco_i;+ function __tco_loop(i) {+ var v = index(arr)(i);+ if (v instanceof Data_Maybe.Just) {+ var $64 = p(v.value0);+ if ($64) {+ __tco_i = i + 1 | 0;+ return;+ };+ __tco_done = true;+ return new Data_Maybe.Just(i);+ };+ if (v instanceof Data_Maybe.Nothing) {+ __tco_done = true;+ return Data_Maybe.Nothing.value;+ };+ throw new Error("Failed pattern match at Data.Array line 528, column 5 - line 530, column 25: " + [ v.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(i);+ i = __tco_i;+ };+ return __tco_result;+ };+ var breakIndex = go(0);+ if (breakIndex instanceof Data_Maybe.Just && breakIndex.value0 === 0) {+ return {+ init: [ ], + rest: arr+ };+ };+ if (breakIndex instanceof Data_Maybe.Just) {+ return {+ init: $foreign.slice(0)(breakIndex.value0)(arr), + rest: $foreign.slice(breakIndex.value0)($foreign.length(arr))(arr)+ };+ };+ if (breakIndex instanceof Data_Maybe.Nothing) {+ return {+ init: arr, + rest: [ ]+ };+ };+ throw new Error("Failed pattern match at Data.Array line 515, column 3 - line 521, column 30: " + [ breakIndex.constructor.name ]);+ };+};+var takeWhile = function (p) {+ return function (xs) {+ return (span(p)(xs)).init;+ };+};+var head = function (xs) {+ return index(xs)(0);+};+var groupBy = function (op) {+ return function (xs) {+ return Control_Monad_ST.pureST(function __do() {+ var v = Data_Array_ST.emptySTArray();+ var v1 = Data_Array_ST_Iterator.iterator(function (v1) {+ return index(xs)(v1);+ })();+ Data_Array_ST_Iterator.iterate(v1)(function (x) {+ return Data_Functor["void"](Control_Monad_Eff.functorEff)(function __do() {+ var v2 = Data_Array_ST.emptySTArray();+ Data_Array_ST_Iterator.pushWhile(op(x))(v1)(v2)();+ var v3 = Data_Array_ST.unsafeFreeze(v2)();+ return Data_Array_ST.pushSTArray(v)(new Data_NonEmpty.NonEmpty(x, v3))();+ });+ })();+ return Data_Array_ST.unsafeFreeze(v)();+ });+ };+};+var group = function (dictEq) {+ return function (xs) {+ return groupBy(Data_Eq.eq(dictEq))(xs);+ };+};+var group$prime = function (dictOrd) {+ return function ($85) {+ return group(dictOrd.Eq0())(sort(dictOrd)($85));+ };+};+var fromFoldable = function (dictFoldable) {+ return $foreign.fromFoldableImpl(Data_Foldable.foldr(dictFoldable));+};+var foldRecM = function (dictMonadRec) {+ return function (f) {+ return function (a) {+ return function (array) {+ var go = function (res) {+ return function (i) {+ if (i >= $foreign.length(array)) {+ return Control_Applicative.pure((dictMonadRec.Monad0()).Applicative0())(new Control_Monad_Rec_Class.Done(res));+ };+ if (Data_Boolean.otherwise) {+ return Control_Bind.bind((dictMonadRec.Monad0()).Bind1())(f(res)(unsafeIndex()(array)(i)))(function (v) {+ return Control_Applicative.pure((dictMonadRec.Monad0()).Applicative0())(new Control_Monad_Rec_Class.Loop({+ a: v, + b: i + 1 | 0+ }));+ });+ };+ throw new Error("Failed pattern match at Data.Array line 671, column 3 - line 675, column 42: " + [ res.constructor.name, i.constructor.name ]);+ };+ };+ return Control_Monad_Rec_Class.tailRecM2(dictMonadRec)(go)(a)(0);+ };+ };+ };+};+var foldM = function (dictMonad) {+ return function (f) {+ return function (a) {+ return $foreign["uncons'"](function (v) {+ return Control_Applicative.pure(dictMonad.Applicative0())(a);+ })(function (b) {+ return function (bs) {+ return Control_Bind.bind(dictMonad.Bind1())(f(a)(b))(function (a$prime) {+ return foldM(dictMonad)(f)(a$prime)(bs);+ });+ };+ });+ };+ };+};+var findLastIndex = $foreign.findLastIndexImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+var insertBy = function (cmp) {+ return function (x) {+ return function (ys) {+ var i = Data_Maybe.maybe(0)(function (v) {+ return v + 1 | 0;+ })(findLastIndex(function (y) {+ return Data_Eq.eq(Data_Ordering.eqOrdering)(cmp(x)(y))(Data_Ordering.GT.value);+ })(ys));+ return Data_Maybe.fromJust()(insertAt(i)(x)(ys));+ };+ };+};+var insert = function (dictOrd) {+ return insertBy(Data_Ord.compare(dictOrd));+};+var findIndex = $foreign.findIndexImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+var intersectBy = function (eq) {+ return function (xs) {+ return function (ys) {+ return $foreign.filter(function (x) {+ return Data_Maybe.isJust(findIndex(eq(x))(ys));+ })(xs);+ };+ };+};+var intersect = function (dictEq) {+ return intersectBy(Data_Eq.eq(dictEq));+};+var elemLastIndex = function (dictEq) {+ return function (x) {+ return findLastIndex(function (v) {+ return Data_Eq.eq(dictEq)(v)(x);+ });+ };+};+var elemIndex = function (dictEq) {+ return function (x) {+ return findIndex(function (v) {+ return Data_Eq.eq(dictEq)(v)(x);+ });+ };+};+var dropWhile = function (p) {+ return function (xs) {+ return (span(p)(xs)).rest;+ };+};+var deleteAt = $foreign._deleteAt(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+var deleteBy = function (v) {+ return function (v1) {+ return function (v2) {+ if (v2.length === 0) {+ return [ ];+ };+ return Data_Maybe.maybe(v2)(function (i) {+ return Data_Maybe.fromJust()(deleteAt(i)(v2));+ })(findIndex(v(v1))(v2));+ };+ };+};+var unionBy = function (eq) {+ return function (xs) {+ return function (ys) {+ return Data_Semigroup.append(Data_Semigroup.semigroupArray)(xs)(Data_Foldable.foldl(Data_Foldable.foldableArray)(Data_Function.flip(deleteBy(eq)))(nubBy(eq)(ys))(xs));+ };+ };+};+var union = function (dictEq) {+ return unionBy(Data_Eq.eq(dictEq));+};+var $$delete = function (dictEq) {+ return deleteBy(Data_Eq.eq(dictEq));+};+var difference = function (dictEq) {+ return Data_Foldable.foldr(Data_Foldable.foldableArray)($$delete(dictEq));+};+var concatMap = Data_Function.flip(Control_Bind.bind(Control_Bind.bindArray));+var mapMaybe = function (f) {+ return concatMap(function ($86) {+ return Data_Maybe.maybe([ ])(singleton)(f($86));+ });+};+var filterA = function (dictApplicative) {+ return function (p) {+ return function ($87) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(mapMaybe(function (v) {+ if (v.value1) {+ return new Data_Maybe.Just(v.value0);+ };+ return Data_Maybe.Nothing.value;+ }))(Data_Traversable.traverse(Data_Traversable.traversableArray)(dictApplicative)(function (x) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Tuple.Tuple.create(x))(p(x));+ })($87));+ };+ };+};+var catMaybes = mapMaybe(Control_Category.id(Control_Category.categoryFn));+var alterAt = function (i) {+ return function (f) {+ return function (xs) {+ var go = function (x) {+ var v = f(x);+ if (v instanceof Data_Maybe.Nothing) {+ return deleteAt(i)(xs);+ };+ if (v instanceof Data_Maybe.Just) {+ return updateAt(i)(v.value0)(xs);+ };+ throw new Error("Failed pattern match at Data.Array line 388, column 10 - line 390, column 32: " + [ v.constructor.name ]);+ };+ return Data_Maybe.maybe(Data_Maybe.Nothing.value)(go)(index(xs)(i));+ };+ };+};+module.exports = {+ alterAt: alterAt, + catMaybes: catMaybes, + concatMap: concatMap, + "delete": $$delete, + deleteAt: deleteAt, + deleteBy: deleteBy, + difference: difference, + dropWhile: dropWhile, + elemIndex: elemIndex, + elemLastIndex: elemLastIndex, + filterA: filterA, + findIndex: findIndex, + findLastIndex: findLastIndex, + foldM: foldM, + foldRecM: foldRecM, + fromFoldable: fromFoldable, + group: group, + "group'": group$prime, + groupBy: groupBy, + head: head, + index: index, + init: init, + insert: insert, + insertAt: insertAt, + insertBy: insertBy, + intersect: intersect, + intersectBy: intersectBy, + last: last, + many: many, + mapMaybe: mapMaybe, + mapWithIndex: mapWithIndex, + modifyAt: modifyAt, + nub: nub, + nubBy: nubBy, + "null": $$null, + singleton: singleton, + some: some, + sort: sort, + sortBy: sortBy, + sortWith: sortWith, + span: span, + tail: tail, + takeWhile: takeWhile, + toUnfoldable: toUnfoldable, + uncons: uncons, + union: union, + unionBy: unionBy, + unsafeIndex: unsafeIndex, + unsnoc: unsnoc, + unzip: unzip, + updateAt: updateAt, + zip: zip, + zipWithA: zipWithA, + concat: $foreign.concat, + cons: $foreign.cons, + drop: $foreign.drop, + filter: $foreign.filter, + length: $foreign.length, + partition: $foreign.partition, + range: $foreign.range, + replicate: $foreign.replicate, + reverse: $foreign.reverse, + slice: $foreign.slice, + snoc: $foreign.snoc, + take: $foreign.take, + zipWith: $foreign.zipWith+};++},{"../Control.Alt":38,"../Control.Alternative":39,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Category":47,"../Control.Lazy":50,"../Control.Monad.Eff":70,"../Control.Monad.Rec.Class":77,"../Control.Monad.ST":79,"../Control.Semigroupoid":92,"../Data.Array.ST":117,"../Data.Array.ST.Iterator":115,"../Data.Boolean":129,"../Data.Eq":138,"../Data.Foldable":143,"../Data.Function":149,"../Data.Functor":155,"../Data.HeytingAlgebra":160,"../Data.Maybe":198,"../Data.NonEmpty":210,"../Data.Ord":216,"../Data.Ordering":217,"../Data.Ring":227,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Traversable":244,"../Data.Tuple":245,"../Data.Unfoldable":247,"../Partial.Unsafe":265,"../Prelude":268,"./foreign":118}],120:[function(require,module,exports){+arguments[4][99][0].apply(exports,arguments)+},{"dup":99}],121:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Category = require("../Control.Category");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Bifunctor_Clown = require("../Data.Bifunctor.Clown");+var Data_Bifunctor_Flip = require("../Data.Bifunctor.Flip");+var Data_Bifunctor_Joker = require("../Data.Bifunctor.Joker");+var Data_Bifunctor_Product = require("../Data.Bifunctor.Product");+var Data_Bifunctor_Wrap = require("../Data.Bifunctor.Wrap");+var Data_Foldable = require("../Data.Foldable");+var Data_Function = require("../Data.Function");+var Data_Monoid = require("../Data.Monoid");+var Data_Monoid_Conj = require("../Data.Monoid.Conj");+var Data_Monoid_Disj = require("../Data.Monoid.Disj");+var Data_Monoid_Dual = require("../Data.Monoid.Dual");+var Data_Monoid_Endo = require("../Data.Monoid.Endo");+var Data_Newtype = require("../Data.Newtype");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var Bifoldable = function (bifoldMap, bifoldl, bifoldr) {+ this.bifoldMap = bifoldMap;+ this.bifoldl = bifoldl;+ this.bifoldr = bifoldr;+};+var bifoldr = function (dict) {+ return dict.bifoldr;+};+var bitraverse_ = function (dictBifoldable) {+ return function (dictApplicative) {+ return function (f) {+ return function (g) {+ return bifoldr(dictBifoldable)(function ($97) {+ return Control_Apply.applySecond(dictApplicative.Apply0())(f($97));+ })(function ($98) {+ return Control_Apply.applySecond(dictApplicative.Apply0())(g($98));+ })(Control_Applicative.pure(dictApplicative)(Data_Unit.unit));+ };+ };+ };+};+var bifor_ = function (dictBifoldable) {+ return function (dictApplicative) {+ return function (t) {+ return function (f) {+ return function (g) {+ return bitraverse_(dictBifoldable)(dictApplicative)(f)(g)(t);+ };+ };+ };+ };+};+var bisequence_ = function (dictBifoldable) {+ return function (dictApplicative) {+ return bitraverse_(dictBifoldable)(dictApplicative)(Control_Category.id(Control_Category.categoryFn))(Control_Category.id(Control_Category.categoryFn));+ };+};+var bifoldl = function (dict) {+ return dict.bifoldl;+};+var bifoldableJoker = function (dictFoldable) {+ return new Bifoldable(function (dictMonoid) {+ return function (v) {+ return function (r) {+ return function (v1) {+ return Data_Foldable.foldMap(dictFoldable)(dictMonoid)(r)(v1);+ };+ };+ };+ }, function (v) {+ return function (r) {+ return function (u) {+ return function (v1) {+ return Data_Foldable.foldl(dictFoldable)(r)(u)(v1);+ };+ };+ };+ }, function (v) {+ return function (r) {+ return function (u) {+ return function (v1) {+ return Data_Foldable.foldr(dictFoldable)(r)(u)(v1);+ };+ };+ };+ });+};+var bifoldableClown = function (dictFoldable) {+ return new Bifoldable(function (dictMonoid) {+ return function (l) {+ return function (v) {+ return function (v1) {+ return Data_Foldable.foldMap(dictFoldable)(dictMonoid)(l)(v1);+ };+ };+ };+ }, function (l) {+ return function (v) {+ return function (u) {+ return function (v1) {+ return Data_Foldable.foldl(dictFoldable)(l)(u)(v1);+ };+ };+ };+ }, function (l) {+ return function (v) {+ return function (u) {+ return function (v1) {+ return Data_Foldable.foldr(dictFoldable)(l)(u)(v1);+ };+ };+ };+ });+};+var bifoldMapDefaultR = function (dictBifoldable) {+ return function (dictMonoid) {+ return function (f) {+ return function (g) {+ return bifoldr(dictBifoldable)(function ($99) {+ return Data_Semigroup.append(dictMonoid.Semigroup0())(f($99));+ })(function ($100) {+ return Data_Semigroup.append(dictMonoid.Semigroup0())(g($100));+ })(Data_Monoid.mempty(dictMonoid));+ };+ };+ };+};+var bifoldMapDefaultL = function (dictBifoldable) {+ return function (dictMonoid) {+ return function (f) {+ return function (g) {+ return bifoldl(dictBifoldable)(function (m) {+ return function (a) {+ return Data_Semigroup.append(dictMonoid.Semigroup0())(m)(f(a));+ };+ })(function (m) {+ return function (b) {+ return Data_Semigroup.append(dictMonoid.Semigroup0())(m)(g(b));+ };+ })(Data_Monoid.mempty(dictMonoid));+ };+ };+ };+};+var bifoldMap = function (dict) {+ return dict.bifoldMap;+};+var bifoldableFlip = function (dictBifoldable) {+ return new Bifoldable(function (dictMonoid) {+ return function (r) {+ return function (l) {+ return function (v) {+ return bifoldMap(dictBifoldable)(dictMonoid)(l)(r)(v);+ };+ };+ };+ }, function (r) {+ return function (l) {+ return function (u) {+ return function (v) {+ return bifoldl(dictBifoldable)(l)(r)(u)(v);+ };+ };+ };+ }, function (r) {+ return function (l) {+ return function (u) {+ return function (v) {+ return bifoldr(dictBifoldable)(l)(r)(u)(v);+ };+ };+ };+ });+};+var bifoldableWrap = function (dictBifoldable) {+ return new Bifoldable(function (dictMonoid) {+ return function (l) {+ return function (r) {+ return function (v) {+ return bifoldMap(dictBifoldable)(dictMonoid)(l)(r)(v);+ };+ };+ };+ }, function (l) {+ return function (r) {+ return function (u) {+ return function (v) {+ return bifoldl(dictBifoldable)(l)(r)(u)(v);+ };+ };+ };+ }, function (l) {+ return function (r) {+ return function (u) {+ return function (v) {+ return bifoldr(dictBifoldable)(l)(r)(u)(v);+ };+ };+ };+ });+};+var bifoldlDefault = function (dictBifoldable) {+ return function (f) {+ return function (g) {+ return function (z) {+ return function (p) {+ return Data_Newtype.unwrap(Data_Monoid_Endo.newtypeEndo)(Data_Newtype.unwrap(Data_Monoid_Dual.newtypeDual)(bifoldMap(dictBifoldable)(Data_Monoid_Dual.monoidDual(Data_Monoid_Endo.monoidEndo))(function ($101) {+ return Data_Monoid_Dual.Dual(Data_Monoid_Endo.Endo(Data_Function.flip(f)($101)));+ })(function ($102) {+ return Data_Monoid_Dual.Dual(Data_Monoid_Endo.Endo(Data_Function.flip(g)($102)));+ })(p)))(z);+ };+ };+ };+ };+};+var bifoldrDefault = function (dictBifoldable) {+ return function (f) {+ return function (g) {+ return function (z) {+ return function (p) {+ return Data_Newtype.unwrap(Data_Monoid_Endo.newtypeEndo)(bifoldMap(dictBifoldable)(Data_Monoid_Endo.monoidEndo)(function ($103) {+ return Data_Monoid_Endo.Endo(f($103));+ })(function ($104) {+ return Data_Monoid_Endo.Endo(g($104));+ })(p))(z);+ };+ };+ };+ };+};+var bifoldableProduct = function (dictBifoldable) {+ return function (dictBifoldable1) {+ return new Bifoldable(function (dictMonoid) {+ return function (l) {+ return function (r) {+ return function (v) {+ return Data_Semigroup.append(dictMonoid.Semigroup0())(bifoldMap(dictBifoldable)(dictMonoid)(l)(r)(v.value0))(bifoldMap(dictBifoldable1)(dictMonoid)(l)(r)(v.value1));+ };+ };+ };+ }, function (l) {+ return function (r) {+ return function (u) {+ return function (m) {+ return bifoldlDefault(bifoldableProduct(dictBifoldable)(dictBifoldable1))(l)(r)(u)(m);+ };+ };+ };+ }, function (l) {+ return function (r) {+ return function (u) {+ return function (m) {+ return bifoldrDefault(bifoldableProduct(dictBifoldable)(dictBifoldable1))(l)(r)(u)(m);+ };+ };+ };+ });+ };+};+var bifold = function (dictBifoldable) {+ return function (dictMonoid) {+ return bifoldMap(dictBifoldable)(dictMonoid)(Control_Category.id(Control_Category.categoryFn))(Control_Category.id(Control_Category.categoryFn));+ };+};+var biany = function (dictBifoldable) {+ return function (dictBooleanAlgebra) {+ return function (p) {+ return function (q) {+ return function ($105) {+ return Data_Newtype.unwrap(Data_Monoid_Disj.newtypeDisj)(bifoldMap(dictBifoldable)(Data_Monoid_Disj.monoidDisj(dictBooleanAlgebra.HeytingAlgebra0()))(function ($106) {+ return Data_Monoid_Disj.Disj(p($106));+ })(function ($107) {+ return Data_Monoid_Disj.Disj(q($107));+ })($105));+ };+ };+ };+ };+};+var biall = function (dictBifoldable) {+ return function (dictBooleanAlgebra) {+ return function (p) {+ return function (q) {+ return function ($108) {+ return Data_Newtype.unwrap(Data_Monoid_Conj.newtypeConj)(bifoldMap(dictBifoldable)(Data_Monoid_Conj.monoidConj(dictBooleanAlgebra.HeytingAlgebra0()))(function ($109) {+ return Data_Monoid_Conj.Conj(p($109));+ })(function ($110) {+ return Data_Monoid_Conj.Conj(q($110));+ })($108));+ };+ };+ };+ };+};+module.exports = {+ Bifoldable: Bifoldable, + biall: biall, + biany: biany, + bifold: bifold, + bifoldMap: bifoldMap, + bifoldMapDefaultL: bifoldMapDefaultL, + bifoldMapDefaultR: bifoldMapDefaultR, + bifoldl: bifoldl, + bifoldlDefault: bifoldlDefault, + bifoldr: bifoldr, + bifoldrDefault: bifoldrDefault, + bifor_: bifor_, + bisequence_: bisequence_, + bitraverse_: bitraverse_, + bifoldableClown: bifoldableClown, + bifoldableJoker: bifoldableJoker, + bifoldableFlip: bifoldableFlip, + bifoldableProduct: bifoldableProduct, + bifoldableWrap: bifoldableWrap+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Category":47,"../Control.Semigroupoid":92,"../Data.Bifunctor.Clown":122,"../Data.Bifunctor.Flip":123,"../Data.Bifunctor.Joker":124,"../Data.Bifunctor.Product":125,"../Data.Bifunctor.Wrap":126,"../Data.Foldable":143,"../Data.Function":149,"../Data.Monoid":207,"../Data.Monoid.Conj":202,"../Data.Monoid.Disj":203,"../Data.Monoid.Dual":204,"../Data.Monoid.Endo":205,"../Data.Newtype":209,"../Data.Semigroup":229,"../Data.Unit":249,"../Prelude":268}],122:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Biapplicative = require("../Control.Biapplicative");+var Control_Biapply = require("../Control.Biapply");+var Data_Bifunctor = require("../Data.Bifunctor");+var Data_Eq = require("../Data.Eq");+var Data_Functor = require("../Data.Functor");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Prelude = require("../Prelude");+var Clown = function (x) {+ return x;+};+var showClown = function (dictShow) {+ return new Data_Show.Show(function (v) {+ return "(Clown " + (Data_Show.show(dictShow)(v) + ")");+ });+};+var ordClown = function (dictOrd) {+ return dictOrd;+};+var newtypeClown = new Data_Newtype.Newtype(function (n) {+ return n;+}, Clown);+var functorClown = new Data_Functor.Functor(function (v) {+ return function (v1) {+ return v1;+ };+});+var eqClown = function (dictEq) {+ return dictEq;+};+var bifunctorClown = function (dictFunctor) {+ return new Data_Bifunctor.Bifunctor(function (f) {+ return function (v) {+ return function (v1) {+ return Data_Functor.map(dictFunctor)(f)(v1);+ };+ };+ });+};+var biapplyClown = function (dictApply) {+ return new Control_Biapply.Biapply(function () {+ return bifunctorClown(dictApply.Functor0());+ }, function (v) {+ return function (v1) {+ return Control_Apply.apply(dictApply)(v)(v1);+ };+ });+};+var biapplicativeClown = function (dictApplicative) {+ return new Control_Biapplicative.Biapplicative(function () {+ return biapplyClown(dictApplicative.Apply0());+ }, function (a) {+ return function (v) {+ return Control_Applicative.pure(dictApplicative)(a);+ };+ });+};+module.exports = {+ Clown: Clown, + newtypeClown: newtypeClown, + eqClown: eqClown, + ordClown: ordClown, + showClown: showClown, + functorClown: functorClown, + bifunctorClown: bifunctorClown, + biapplyClown: biapplyClown, + biapplicativeClown: biapplicativeClown+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Biapplicative":43,"../Control.Biapply":44,"../Data.Bifunctor":127,"../Data.Eq":138,"../Data.Functor":155,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Semigroup":229,"../Data.Show":233,"../Prelude":268}],123:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Biapplicative = require("../Control.Biapplicative");+var Control_Biapply = require("../Control.Biapply");+var Data_Bifunctor = require("../Data.Bifunctor");+var Data_Eq = require("../Data.Eq");+var Data_Functor = require("../Data.Functor");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Prelude = require("../Prelude");+var Flip = function (x) {+ return x;+};+var showFlip = function (dictShow) {+ return new Data_Show.Show(function (v) {+ return "(Flip " + (Data_Show.show(dictShow)(v) + ")");+ });+};+var ordFlip = function (dictOrd) {+ return dictOrd;+};+var newtypeFlip = new Data_Newtype.Newtype(function (n) {+ return n;+}, Flip);+var functorFlip = function (dictBifunctor) {+ return new Data_Functor.Functor(function (f) {+ return function (v) {+ return Data_Bifunctor.lmap(dictBifunctor)(f)(v);+ };+ });+};+var eqFlip = function (dictEq) {+ return dictEq;+};+var bifunctorFlip = function (dictBifunctor) {+ return new Data_Bifunctor.Bifunctor(function (f) {+ return function (g) {+ return function (v) {+ return Data_Bifunctor.bimap(dictBifunctor)(g)(f)(v);+ };+ };+ });+};+var biapplyFlip = function (dictBiapply) {+ return new Control_Biapply.Biapply(function () {+ return bifunctorFlip(dictBiapply.Bifunctor0());+ }, function (v) {+ return function (v1) {+ return Control_Biapply.biapply(dictBiapply)(v)(v1);+ };+ });+};+var biapplicativeFlip = function (dictBiapplicative) {+ return new Control_Biapplicative.Biapplicative(function () {+ return biapplyFlip(dictBiapplicative.Biapply0());+ }, function (a) {+ return function (b) {+ return Control_Biapplicative.bipure(dictBiapplicative)(b)(a);+ };+ });+};+module.exports = {+ Flip: Flip, + newtypeFlip: newtypeFlip, + eqFlip: eqFlip, + ordFlip: ordFlip, + showFlip: showFlip, + functorFlip: functorFlip, + bifunctorFlip: bifunctorFlip, + biapplyFlip: biapplyFlip, + biapplicativeFlip: biapplicativeFlip+};++},{"../Control.Biapplicative":43,"../Control.Biapply":44,"../Data.Bifunctor":127,"../Data.Eq":138,"../Data.Functor":155,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Semigroup":229,"../Data.Show":233,"../Prelude":268}],124:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Biapplicative = require("../Control.Biapplicative");+var Control_Biapply = require("../Control.Biapply");+var Data_Bifunctor = require("../Data.Bifunctor");+var Data_Eq = require("../Data.Eq");+var Data_Functor = require("../Data.Functor");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Prelude = require("../Prelude");+var Joker = function (x) {+ return x;+};+var showJoker = function (dictShow) {+ return new Data_Show.Show(function (v) {+ return "(Joker " + (Data_Show.show(dictShow)(v) + ")");+ });+};+var ordJoker = function (dictOrd) {+ return dictOrd;+};+var newtypeJoker = new Data_Newtype.Newtype(function (n) {+ return n;+}, Joker);+var functorJoker = function (dictFunctor) {+ return new Data_Functor.Functor(function (g) {+ return function (v) {+ return Data_Functor.map(dictFunctor)(g)(v);+ };+ });+};+var eqJoker = function (dictEq) {+ return dictEq;+};+var bifunctorJoker = function (dictFunctor) {+ return new Data_Bifunctor.Bifunctor(function (v) {+ return function (g) {+ return function (v1) {+ return Data_Functor.map(dictFunctor)(g)(v1);+ };+ };+ });+};+var biapplyJoker = function (dictApply) {+ return new Control_Biapply.Biapply(function () {+ return bifunctorJoker(dictApply.Functor0());+ }, function (v) {+ return function (v1) {+ return Control_Apply.apply(dictApply)(v)(v1);+ };+ });+};+var biapplicativeJoker = function (dictApplicative) {+ return new Control_Biapplicative.Biapplicative(function () {+ return biapplyJoker(dictApplicative.Apply0());+ }, function (v) {+ return function (b) {+ return Control_Applicative.pure(dictApplicative)(b);+ };+ });+};+module.exports = {+ Joker: Joker, + newtypeJoker: newtypeJoker, + eqJoker: eqJoker, + ordJoker: ordJoker, + showJoker: showJoker, + functorJoker: functorJoker, + bifunctorJoker: bifunctorJoker, + biapplyJoker: biapplyJoker, + biapplicativeJoker: biapplicativeJoker+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Biapplicative":43,"../Control.Biapply":44,"../Data.Bifunctor":127,"../Data.Eq":138,"../Data.Functor":155,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Semigroup":229,"../Data.Show":233,"../Prelude":268}],125:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Biapplicative = require("../Control.Biapplicative");+var Control_Biapply = require("../Control.Biapply");+var Data_Bifunctor = require("../Data.Bifunctor");+var Data_Eq = require("../Data.Eq");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Ord = require("../Data.Ord");+var Data_Ordering = require("../Data.Ordering");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Prelude = require("../Prelude");+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 showProduct = function (dictShow) {+ return function (dictShow1) {+ return new Data_Show.Show(function (v) {+ return "(Product " + (Data_Show.show(dictShow)(v.value0) + (" " + (Data_Show.show(dictShow1)(v.value1) + ")")));+ });+ };+};+var eqProduct = function (dictEq) {+ return function (dictEq1) {+ return new Data_Eq.Eq(function (x) {+ return function (y) {+ return Data_Eq.eq(dictEq)(x.value0)(y.value0) && Data_Eq.eq(dictEq1)(x.value1)(y.value1);+ };+ });+ };+};+var ordProduct = function (dictOrd) {+ return function (dictOrd1) {+ return new Data_Ord.Ord(function () {+ return eqProduct(dictOrd.Eq0())(dictOrd1.Eq0());+ }, function (x) {+ return function (y) {+ var v = Data_Ord.compare(dictOrd)(x.value0)(y.value0);+ if (v instanceof Data_Ordering.LT) {+ return Data_Ordering.LT.value;+ };+ if (v instanceof Data_Ordering.GT) {+ return Data_Ordering.GT.value;+ };+ return Data_Ord.compare(dictOrd1)(x.value1)(y.value1);+ };+ });+ };+};+var bifunctorProduct = function (dictBifunctor) {+ return function (dictBifunctor1) {+ return new Data_Bifunctor.Bifunctor(function (f) {+ return function (g) {+ return function (v) {+ return new Product(Data_Bifunctor.bimap(dictBifunctor)(f)(g)(v.value0), Data_Bifunctor.bimap(dictBifunctor1)(f)(g)(v.value1));+ };+ };+ });+ };+};+var biapplyProduct = function (dictBiapply) {+ return function (dictBiapply1) {+ return new Control_Biapply.Biapply(function () {+ return bifunctorProduct(dictBiapply.Bifunctor0())(dictBiapply1.Bifunctor0());+ }, function (v) {+ return function (v1) {+ return new Product(Control_Biapply.biapply(dictBiapply)(v.value0)(v1.value0), Control_Biapply.biapply(dictBiapply1)(v.value1)(v1.value1));+ };+ });+ };+};+var biapplicativeProduct = function (dictBiapplicative) {+ return function (dictBiapplicative1) {+ return new Control_Biapplicative.Biapplicative(function () {+ return biapplyProduct(dictBiapplicative.Biapply0())(dictBiapplicative1.Biapply0());+ }, function (a) {+ return function (b) {+ return new Product(Control_Biapplicative.bipure(dictBiapplicative)(a)(b), Control_Biapplicative.bipure(dictBiapplicative1)(a)(b));+ };+ });+ };+};+module.exports = {+ Product: Product, + eqProduct: eqProduct, + ordProduct: ordProduct, + showProduct: showProduct, + bifunctorProduct: bifunctorProduct, + biapplyProduct: biapplyProduct, + biapplicativeProduct: biapplicativeProduct+};++},{"../Control.Biapplicative":43,"../Control.Biapply":44,"../Data.Bifunctor":127,"../Data.Eq":138,"../Data.HeytingAlgebra":160,"../Data.Ord":216,"../Data.Ordering":217,"../Data.Semigroup":229,"../Data.Show":233,"../Prelude":268}],126:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Biapplicative = require("../Control.Biapplicative");+var Control_Biapply = require("../Control.Biapply");+var Data_Bifunctor = require("../Data.Bifunctor");+var Data_Eq = require("../Data.Eq");+var Data_Functor = require("../Data.Functor");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Prelude = require("../Prelude");+var Wrap = function (x) {+ return x;+};+var showWrap = function (dictShow) {+ return new Data_Show.Show(function (v) {+ return "(Wrap " + (Data_Show.show(dictShow)(v) + ")");+ });+};+var ordWrap = function (dictOrd) {+ return dictOrd;+};+var newtypeWrap = new Data_Newtype.Newtype(function (n) {+ return n;+}, Wrap);+var functorWrap = function (dictBifunctor) {+ return new Data_Functor.Functor(function (f) {+ return function (v) {+ return Data_Bifunctor.rmap(dictBifunctor)(f)(v);+ };+ });+};+var eqWrap = function (dictEq) {+ return dictEq;+};+var bifunctorWrap = function (dictBifunctor) {+ return new Data_Bifunctor.Bifunctor(function (f) {+ return function (g) {+ return function (v) {+ return Data_Bifunctor.bimap(dictBifunctor)(f)(g)(v);+ };+ };+ });+};+var biapplyWrap = function (dictBiapply) {+ return new Control_Biapply.Biapply(function () {+ return bifunctorWrap(dictBiapply.Bifunctor0());+ }, function (v) {+ return function (v1) {+ return Control_Biapply.biapply(dictBiapply)(v)(v1);+ };+ });+};+var biapplicativeWrap = function (dictBiapplicative) {+ return new Control_Biapplicative.Biapplicative(function () {+ return biapplyWrap(dictBiapplicative.Biapply0());+ }, function (a) {+ return function (b) {+ return Control_Biapplicative.bipure(dictBiapplicative)(a)(b);+ };+ });+};+module.exports = {+ Wrap: Wrap, + newtypeWrap: newtypeWrap, + eqWrap: eqWrap, + ordWrap: ordWrap, + showWrap: showWrap, + functorWrap: functorWrap, + bifunctorWrap: bifunctorWrap, + biapplyWrap: biapplyWrap, + biapplicativeWrap: biapplicativeWrap+};++},{"../Control.Biapplicative":43,"../Control.Biapply":44,"../Data.Bifunctor":127,"../Data.Eq":138,"../Data.Functor":155,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Semigroup":229,"../Data.Show":233,"../Prelude":268}],127:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var Bifunctor = function (bimap) {+ this.bimap = bimap;+};+var bimap = function (dict) {+ return dict.bimap;+};+var lmap = function (dictBifunctor) {+ return function (f) {+ return bimap(dictBifunctor)(f)(Control_Category.id(Control_Category.categoryFn));+ };+};+var rmap = function (dictBifunctor) {+ return bimap(dictBifunctor)(Control_Category.id(Control_Category.categoryFn));+};+module.exports = {+ Bifunctor: Bifunctor, + bimap: bimap, + lmap: lmap, + rmap: rmap+};++},{"../Control.Category":47}],128:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Category = require("../Control.Category");+var Data_Bifoldable = require("../Data.Bifoldable");+var Data_Bifunctor = require("../Data.Bifunctor");+var Data_Bifunctor_Clown = require("../Data.Bifunctor.Clown");+var Data_Bifunctor_Flip = require("../Data.Bifunctor.Flip");+var Data_Bifunctor_Joker = require("../Data.Bifunctor.Joker");+var Data_Bifunctor_Product = require("../Data.Bifunctor.Product");+var Data_Bifunctor_Wrap = require("../Data.Bifunctor.Wrap");+var Data_Functor = require("../Data.Functor");+var Data_Traversable = require("../Data.Traversable");+var Prelude = require("../Prelude");+var Bitraversable = function (Bifoldable1, Bifunctor0, bisequence, bitraverse) {+ this.Bifoldable1 = Bifoldable1;+ this.Bifunctor0 = Bifunctor0;+ this.bisequence = bisequence;+ this.bitraverse = bitraverse;+};+var bitraverse = function (dict) {+ return dict.bitraverse;+};+var lfor = function (dictBitraversable) {+ return function (dictApplicative) {+ return function (t) {+ return function (f) {+ return bitraverse(dictBitraversable)(dictApplicative)(f)(Control_Applicative.pure(dictApplicative))(t);+ };+ };+ };+};+var ltraverse = function (dictBitraversable) {+ return function (dictApplicative) {+ return function (f) {+ return bitraverse(dictBitraversable)(dictApplicative)(f)(Control_Applicative.pure(dictApplicative));+ };+ };+};+var rfor = function (dictBitraversable) {+ return function (dictApplicative) {+ return function (t) {+ return function (f) {+ return bitraverse(dictBitraversable)(dictApplicative)(Control_Applicative.pure(dictApplicative))(f)(t);+ };+ };+ };+};+var rtraverse = function (dictBitraversable) {+ return function (dictApplicative) {+ return bitraverse(dictBitraversable)(dictApplicative)(Control_Applicative.pure(dictApplicative));+ };+};+var bitraversableJoker = function (dictTraversable) {+ return new Bitraversable(function () {+ return Data_Bifoldable.bifoldableJoker(dictTraversable.Foldable1());+ }, function () {+ return Data_Bifunctor_Joker.bifunctorJoker(dictTraversable.Functor0());+ }, function (dictApplicative) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Bifunctor_Joker.Joker)(Data_Traversable.sequence(dictTraversable)(dictApplicative)(v));+ };+ }, function (dictApplicative) {+ return function (v) {+ return function (r) {+ return function (v1) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Bifunctor_Joker.Joker)(Data_Traversable.traverse(dictTraversable)(dictApplicative)(r)(v1));+ };+ };+ };+ });+};+var bitraversableClown = function (dictTraversable) {+ return new Bitraversable(function () {+ return Data_Bifoldable.bifoldableClown(dictTraversable.Foldable1());+ }, function () {+ return Data_Bifunctor_Clown.bifunctorClown(dictTraversable.Functor0());+ }, function (dictApplicative) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Bifunctor_Clown.Clown)(Data_Traversable.sequence(dictTraversable)(dictApplicative)(v));+ };+ }, function (dictApplicative) {+ return function (l) {+ return function (v) {+ return function (v1) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Bifunctor_Clown.Clown)(Data_Traversable.traverse(dictTraversable)(dictApplicative)(l)(v1));+ };+ };+ };+ });+};+var bisequenceDefault = function (dictBitraversable) {+ return function (dictApplicative) {+ return bitraverse(dictBitraversable)(dictApplicative)(Control_Category.id(Control_Category.categoryFn))(Control_Category.id(Control_Category.categoryFn));+ };+};+var bisequence = function (dict) {+ return dict.bisequence;+};+var bitraversableFlip = function (dictBitraversable) {+ return new Bitraversable(function () {+ return Data_Bifoldable.bifoldableFlip(dictBitraversable.Bifoldable1());+ }, function () {+ return Data_Bifunctor_Flip.bifunctorFlip(dictBitraversable.Bifunctor0());+ }, function (dictApplicative) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Bifunctor_Flip.Flip)(bisequence(dictBitraversable)(dictApplicative)(v));+ };+ }, function (dictApplicative) {+ return function (r) {+ return function (l) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Bifunctor_Flip.Flip)(bitraverse(dictBitraversable)(dictApplicative)(l)(r)(v));+ };+ };+ };+ });+};+var bitraversableProduct = function (dictBitraversable) {+ return function (dictBitraversable1) {+ return new Bitraversable(function () {+ return Data_Bifoldable.bifoldableProduct(dictBitraversable.Bifoldable1())(dictBitraversable1.Bifoldable1());+ }, function () {+ return Data_Bifunctor_Product.bifunctorProduct(dictBitraversable.Bifunctor0())(dictBitraversable1.Bifunctor0());+ }, function (dictApplicative) {+ return function (v) {+ return Control_Apply.apply(dictApplicative.Apply0())(Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Bifunctor_Product.Product.create)(bisequence(dictBitraversable)(dictApplicative)(v.value0)))(bisequence(dictBitraversable1)(dictApplicative)(v.value1));+ };+ }, function (dictApplicative) {+ return function (l) {+ return function (r) {+ return function (v) {+ return Control_Apply.apply(dictApplicative.Apply0())(Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Bifunctor_Product.Product.create)(bitraverse(dictBitraversable)(dictApplicative)(l)(r)(v.value0)))(bitraverse(dictBitraversable1)(dictApplicative)(l)(r)(v.value1));+ };+ };+ };+ });+ };+};+var bitraversableWrap = function (dictBitraversable) {+ return new Bitraversable(function () {+ return Data_Bifoldable.bifoldableWrap(dictBitraversable.Bifoldable1());+ }, function () {+ return Data_Bifunctor_Wrap.bifunctorWrap(dictBitraversable.Bifunctor0());+ }, function (dictApplicative) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Bifunctor_Wrap.Wrap)(bisequence(dictBitraversable)(dictApplicative)(v));+ };+ }, function (dictApplicative) {+ return function (l) {+ return function (r) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Bifunctor_Wrap.Wrap)(bitraverse(dictBitraversable)(dictApplicative)(l)(r)(v));+ };+ };+ };+ });+};+var bitraverseDefault = function (dictBitraversable) {+ return function (dictApplicative) {+ return function (f) {+ return function (g) {+ return function (t) {+ return bisequence(dictBitraversable)(dictApplicative)(Data_Bifunctor.bimap(dictBitraversable.Bifunctor0())(f)(g)(t));+ };+ };+ };+ };+};+var bifor = function (dictBitraversable) {+ return function (dictApplicative) {+ return function (t) {+ return function (f) {+ return function (g) {+ return bitraverse(dictBitraversable)(dictApplicative)(f)(g)(t);+ };+ };+ };+ };+};+module.exports = {+ Bitraversable: Bitraversable, + bifor: bifor, + bisequence: bisequence, + bisequenceDefault: bisequenceDefault, + bitraverse: bitraverse, + bitraverseDefault: bitraverseDefault, + lfor: lfor, + ltraverse: ltraverse, + rfor: rfor, + rtraverse: rtraverse, + bitraversableClown: bitraversableClown, + bitraversableJoker: bitraversableJoker, + bitraversableFlip: bitraversableFlip, + bitraversableProduct: bitraversableProduct, + bitraversableWrap: bitraversableWrap+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Category":47,"../Data.Bifoldable":121,"../Data.Bifunctor":127,"../Data.Bifunctor.Clown":122,"../Data.Bifunctor.Flip":123,"../Data.Bifunctor.Joker":124,"../Data.Bifunctor.Product":125,"../Data.Bifunctor.Wrap":126,"../Data.Functor":155,"../Data.Traversable":244,"../Prelude":268}],129:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var otherwise = true;+module.exports = {+ otherwise: otherwise+};++},{}],130:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Unit = require("../Data.Unit");+var BooleanAlgebra = function (HeytingAlgebra0) {+ this.HeytingAlgebra0 = HeytingAlgebra0;+};+var booleanAlgebraUnit = new BooleanAlgebra(function () {+ return Data_HeytingAlgebra.heytingAlgebraUnit;+});+var booleanAlgebraFn = function (dictBooleanAlgebra) {+ return new BooleanAlgebra(function () {+ return Data_HeytingAlgebra.heytingAlgebraFunction(dictBooleanAlgebra.HeytingAlgebra0());+ });+};+var booleanAlgebraBoolean = new BooleanAlgebra(function () {+ return Data_HeytingAlgebra.heytingAlgebraBoolean;+});+module.exports = {+ BooleanAlgebra: BooleanAlgebra, + booleanAlgebraBoolean: booleanAlgebraBoolean, + booleanAlgebraUnit: booleanAlgebraUnit, + booleanAlgebraFn: booleanAlgebraFn+};++},{"../Data.HeytingAlgebra":160,"../Data.Unit":249}],131:[function(require,module,exports){+"use strict";++exports.topInt = 2147483647;+exports.bottomInt = -2147483648;++exports.topChar = String.fromCharCode(65535);+exports.bottomChar = String.fromCharCode(0);++},{}],132:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Data_Ord = require("../Data.Ord");+var Data_Ordering = require("../Data.Ordering");+var Data_Unit = require("../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 boundedUnit = new Bounded(function () {+ return Data_Ord.ordUnit;+}, Data_Unit.unit, Data_Unit.unit);+var boundedOrdering = new Bounded(function () {+ return Data_Ord.ordOrdering;+}, Data_Ordering.LT.value, Data_Ordering.GT.value);+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 boundedBoolean = new Bounded(function () {+ return Data_Ord.ordBoolean;+}, false, true);+var bottom = function (dict) {+ return dict.bottom;+};+module.exports = {+ Bounded: Bounded, + bottom: bottom, + top: top, + boundedBoolean: boundedBoolean, + boundedInt: boundedInt, + boundedChar: boundedChar, + boundedOrdering: boundedOrdering, + boundedUnit: boundedUnit+};++},{"../Data.Ord":216,"../Data.Ordering":217,"../Data.Unit":249,"./foreign":131}],133:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Ring = require("../Data.Ring");+var Data_Semiring = require("../Data.Semiring");+var Data_Unit = require("../Data.Unit");+var CommutativeRing = function (Ring0) {+ this.Ring0 = Ring0;+};+var commutativeRingUnit = new CommutativeRing(function () {+ return Data_Ring.ringUnit;+});+var commutativeRingNumber = new CommutativeRing(function () {+ return Data_Ring.ringNumber;+});+var commutativeRingInt = new CommutativeRing(function () {+ return Data_Ring.ringInt;+});+var commutativeRingFn = function (dictCommutativeRing) {+ return new CommutativeRing(function () {+ return Data_Ring.ringFn(dictCommutativeRing.Ring0());+ });+};+module.exports = {+ CommutativeRing: CommutativeRing, + commutativeRingInt: commutativeRingInt, + commutativeRingNumber: commutativeRingNumber, + commutativeRingUnit: commutativeRingUnit, + commutativeRingFn: commutativeRingFn+};++},{"../Data.Ring":227,"../Data.Semiring":231,"../Data.Unit":249}],134:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_BooleanAlgebra = require("../Data.BooleanAlgebra");+var Data_Bounded = require("../Data.Bounded");+var Data_CommutativeRing = require("../Data.CommutativeRing");+var Data_Eq = require("../Data.Eq");+var Data_EuclideanRing = require("../Data.EuclideanRing");+var Data_Field = require("../Data.Field");+var Data_Foldable = require("../Data.Foldable");+var Data_Functor = require("../Data.Functor");+var Data_Functor_Contravariant = require("../Data.Functor.Contravariant");+var Data_Functor_Invariant = require("../Data.Functor.Invariant");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Monoid = require("../Data.Monoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Ring = require("../Data.Ring");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Show = require("../Data.Show");+var Data_Traversable = require("../Data.Traversable");+var Prelude = require("../Prelude");+var Const = function (x) {+ return x;+};+var showConst = function (dictShow) {+ return new Data_Show.Show(function (v) {+ return "(Const " + (Data_Show.show(dictShow)(v) + ")");+ });+};+var semiringConst = function (dictSemiring) {+ return dictSemiring;+};+var semigroupoidConst = new Control_Semigroupoid.Semigroupoid(function (v) {+ return function (v1) {+ return v1;+ };+});+var semigroupConst = function (dictSemigroup) {+ return dictSemigroup;+};+var ringConst = function (dictRing) {+ return dictRing;+};+var ordConst = function (dictOrd) {+ return dictOrd;+};+var newtypeConst = new Data_Newtype.Newtype(function (n) {+ return n;+}, Const);+var monoidConst = function (dictMonoid) {+ return dictMonoid;+};+var heytingAlgebraConst = function (dictHeytingAlgebra) {+ return dictHeytingAlgebra;+};+var functorConst = new Data_Functor.Functor(function (v) {+ return function (v1) {+ return v1;+ };+});+var invariantConst = new Data_Functor_Invariant.Invariant(Data_Functor_Invariant.imapF(functorConst));+var foldableConst = new Data_Foldable.Foldable(function (dictMonoid) {+ return function (v) {+ return function (v1) {+ return Data_Monoid.mempty(dictMonoid);+ };+ };+}, function (v) {+ return function (z) {+ return function (v1) {+ return z;+ };+ };+}, function (v) {+ return function (z) {+ return function (v1) {+ return z;+ };+ };+});+var traversableConst = new Data_Traversable.Traversable(function () {+ return foldableConst;+}, function () {+ return functorConst;+}, function (dictApplicative) {+ return function (v) {+ return Control_Applicative.pure(dictApplicative)(v);+ };+}, function (dictApplicative) {+ return function (v) {+ return function (v1) {+ return Control_Applicative.pure(dictApplicative)(v1);+ };+ };+});+var fieldConst = function (dictField) {+ return dictField;+};+var euclideanRingConst = function (dictEuclideanRing) {+ return dictEuclideanRing;+};+var eqConst = function (dictEq) {+ return dictEq;+};+var contravariantConst = new Data_Functor_Contravariant.Contravariant(function (v) {+ return function (v1) {+ return v1;+ };+});+var commutativeRingConst = function (dictCommutativeRing) {+ return dictCommutativeRing;+};+var boundedConst = function (dictBounded) {+ return dictBounded;+};+var booleanAlgebraConst = function (dictBooleanAlgebra) {+ return dictBooleanAlgebra;+};+var applyConst = function (dictSemigroup) {+ return new Control_Apply.Apply(function () {+ return functorConst;+ }, function (v) {+ return function (v1) {+ return Data_Semigroup.append(dictSemigroup)(v)(v1);+ };+ });+};+var bindConst = function (dictSemigroup) {+ return new Control_Bind.Bind(function () {+ return applyConst(dictSemigroup);+ }, function (v) {+ return function (v1) {+ return v;+ };+ });+};+var applicativeConst = function (dictMonoid) {+ return new Control_Applicative.Applicative(function () {+ return applyConst(dictMonoid.Semigroup0());+ }, function (v) {+ return Data_Monoid.mempty(dictMonoid);+ });+};+module.exports = {+ Const: Const, + newtypeConst: newtypeConst, + eqConst: eqConst, + ordConst: ordConst, + boundedConst: boundedConst, + showConst: showConst, + semigroupoidConst: semigroupoidConst, + semigroupConst: semigroupConst, + monoidConst: monoidConst, + semiringConst: semiringConst, + ringConst: ringConst, + euclideanRingConst: euclideanRingConst, + commutativeRingConst: commutativeRingConst, + fieldConst: fieldConst, + heytingAlgebraConst: heytingAlgebraConst, + booleanAlgebraConst: booleanAlgebraConst, + functorConst: functorConst, + invariantConst: invariantConst, + contravariantConst: contravariantConst, + applyConst: applyConst, + bindConst: bindConst, + applicativeConst: applicativeConst, + foldableConst: foldableConst, + traversableConst: traversableConst+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Semigroupoid":92,"../Data.BooleanAlgebra":130,"../Data.Bounded":132,"../Data.CommutativeRing":133,"../Data.Eq":138,"../Data.EuclideanRing":140,"../Data.Field":141,"../Data.Foldable":143,"../Data.Functor":155,"../Data.Functor.Contravariant":152,"../Data.Functor.Invariant":153,"../Data.HeytingAlgebra":160,"../Data.Monoid":207,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Ring":227,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Show":233,"../Data.Traversable":244,"../Prelude":268}],135:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Identity = require("../Data.Identity");+var Data_Newtype = require("../Data.Newtype");+var Prelude = require("../Prelude");+var Distributive = function (Functor0, collect, distribute) {+ this.Functor0 = Functor0;+ this.collect = collect;+ this.distribute = distribute;+};+var distributiveIdentity = new Distributive(function () {+ return Data_Identity.functorIdentity;+}, function (dictFunctor) {+ return function (f) {+ return function ($11) {+ return Data_Identity.Identity(Data_Functor.map(dictFunctor)(function ($12) {+ return Data_Newtype.unwrap(Data_Identity.newtypeIdentity)(f($12));+ })($11));+ };+ };+}, function (dictFunctor) {+ return function ($13) {+ return Data_Identity.Identity(Data_Functor.map(dictFunctor)(Data_Newtype.unwrap(Data_Identity.newtypeIdentity))($13));+ };+});+var distribute = function (dict) {+ return dict.distribute;+};+var distributiveFunction = new Distributive(function () {+ return Data_Functor.functorFn;+}, function (dictFunctor) {+ return function (f) {+ return function ($14) {+ return distribute(distributiveFunction)(dictFunctor)(Data_Functor.map(dictFunctor)(f)($14));+ };+ };+}, function (dictFunctor) {+ return function (a) {+ return function (e) {+ return Data_Functor.map(dictFunctor)(function (v) {+ return v(e);+ })(a);+ };+ };+});+var cotraverse = function (dictDistributive) {+ return function (dictFunctor) {+ return function (f) {+ return function ($15) {+ return Data_Functor.map(dictDistributive.Functor0())(f)(distribute(dictDistributive)(dictFunctor)($15));+ };+ };+ };+};+var collectDefault = function (dictDistributive) {+ return function (dictFunctor) {+ return function (f) {+ return function ($16) {+ return distribute(dictDistributive)(dictFunctor)(Data_Functor.map(dictFunctor)(f)($16));+ };+ };+ };+};+var collect = function (dict) {+ return dict.collect;+};+var distributeDefault = function (dictDistributive) {+ return function (dictFunctor) {+ return collect(dictDistributive)(dictFunctor)(Control_Category.id(Control_Category.categoryFn));+ };+};+module.exports = {+ Distributive: Distributive, + collect: collect, + collectDefault: collectDefault, + cotraverse: cotraverse, + distribute: distribute, + distributeDefault: distributeDefault, + distributiveIdentity: distributiveIdentity, + distributiveFunction: distributiveFunction+};++},{"../Control.Category":47,"../Control.Semigroupoid":92,"../Data.Function":149,"../Data.Functor":155,"../Data.Identity":161,"../Data.Newtype":209,"../Prelude":268}],136:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Extend = require("../Control.Extend");+var Control_Monad = require("../Control.Monad");+var Data_Bifoldable = require("../Data.Bifoldable");+var Data_Bifunctor = require("../Data.Bifunctor");+var Data_Bitraversable = require("../Data.Bitraversable");+var Data_Bounded = require("../Data.Bounded");+var Data_Eq = require("../Data.Eq");+var Data_Foldable = require("../Data.Foldable");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Functor_Invariant = require("../Data.Functor.Invariant");+var Data_Monoid = require("../Data.Monoid");+var Data_Ord = require("../Data.Ord");+var Data_Ordering = require("../Data.Ordering");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Show = require("../Data.Show");+var Data_Traversable = require("../Data.Traversable");+var Prelude = require("../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 showEither = function (dictShow) {+ return function (dictShow1) {+ return new Data_Show.Show(function (v) {+ if (v instanceof Left) {+ return "(Left " + (Data_Show.show(dictShow)(v.value0) + ")");+ };+ if (v instanceof Right) {+ return "(Right " + (Data_Show.show(dictShow1)(v.value0) + ")");+ };+ throw new Error("Failed pattern match at Data.Either line 161, column 3 - line 162, column 3: " + [ v.constructor.name ]);+ });+ };+};+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 37, column 3 - line 37, column 26: " + [ v.constructor.name, v1.constructor.name ]);+ };+});+var invariantEither = new Data_Functor_Invariant.Invariant(Data_Functor_Invariant.imapF(functorEither));+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 253, column 1 - line 253, column 23: " + [ v.constructor.name ]);+ })());+ };+};+var fromLeft = function (dictPartial) {+ return function (v) {+ var __unused = function (dictPartial1) {+ return function ($dollar66) {+ return $dollar66;+ };+ };+ return __unused(dictPartial)((function () {+ if (v instanceof Left) {+ return v.value0;+ };+ throw new Error("Failed pattern match at Data.Either line 248, column 1 - line 248, column 22: " + [ v.constructor.name ]);+ })());+ };+};+var foldableEither = new Data_Foldable.Foldable(function (dictMonoid) {+ return function (f) {+ return function (v) {+ if (v instanceof Left) {+ return Data_Monoid.mempty(dictMonoid);+ };+ if (v instanceof Right) {+ return f(v.value0);+ };+ throw new Error("Failed pattern match at Data.Either line 189, column 3 - line 189, column 31: " + [ f.constructor.name, v.constructor.name ]);+ };+ };+}, function (v) {+ return function (z) {+ return function (v1) {+ if (v1 instanceof Left) {+ return z;+ };+ if (v1 instanceof Right) {+ return v(z)(v1.value0);+ };+ throw new Error("Failed pattern match at Data.Either line 187, column 3 - line 187, column 26: " + [ v.constructor.name, z.constructor.name, v1.constructor.name ]);+ };+ };+}, function (v) {+ return function (z) {+ return function (v1) {+ if (v1 instanceof Left) {+ return z;+ };+ if (v1 instanceof Right) {+ return v(v1.value0)(z);+ };+ throw new Error("Failed pattern match at Data.Either line 185, column 3 - line 185, column 26: " + [ v.constructor.name, z.constructor.name, v1.constructor.name ]);+ };+ };+});+var traversableEither = new Data_Traversable.Traversable(function () {+ return foldableEither;+}, function () {+ return functorEither;+}, function (dictApplicative) {+ return function (v) {+ if (v instanceof Left) {+ return Control_Applicative.pure(dictApplicative)(new Left(v.value0));+ };+ if (v instanceof Right) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Right.create)(v.value0);+ };+ throw new Error("Failed pattern match at Data.Either line 203, column 3 - line 203, column 36: " + [ v.constructor.name ]);+ };+}, function (dictApplicative) {+ return function (v) {+ return function (v1) {+ if (v1 instanceof Left) {+ return Control_Applicative.pure(dictApplicative)(new Left(v1.value0));+ };+ if (v1 instanceof Right) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Right.create)(v(v1.value0));+ };+ throw new Error("Failed pattern match at Data.Either line 201, column 3 - line 201, column 39: " + [ v.constructor.name, v1.constructor.name ]);+ };+ };+});+var extendEither = new Control_Extend.Extend(function () {+ return functorEither;+}, function (v) {+ return function (v1) {+ if (v1 instanceof Left) {+ return new Left(v1.value0);+ };+ return new Right(v(v1));+ };+});+var eqEither = function (dictEq) {+ return function (dictEq1) {+ return new Data_Eq.Eq(function (x) {+ return function (y) {+ if (x instanceof Left && y instanceof Left) {+ return Data_Eq.eq(dictEq)(x.value0)(y.value0);+ };+ if (x instanceof Right && y instanceof Right) {+ return Data_Eq.eq(dictEq1)(x.value0)(y.value0);+ };+ return false;+ };+ });+ };+};+var ordEither = function (dictOrd) {+ return function (dictOrd1) {+ return new Data_Ord.Ord(function () {+ return eqEither(dictOrd.Eq0())(dictOrd1.Eq0());+ }, function (x) {+ return function (y) {+ if (x instanceof Left && y instanceof Left) {+ return Data_Ord.compare(dictOrd)(x.value0)(y.value0);+ };+ if (x instanceof Left) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof Left) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof Right && y instanceof Right) {+ return Data_Ord.compare(dictOrd1)(x.value0)(y.value0);+ };+ throw new Error("Failed pattern match at Data.Either line 176, column 1 - line 176, column 64: " + [ x.constructor.name, y.constructor.name ]);+ };+ });+ };+};+var eq1Either = function (dictEq) {+ return new Data_Eq.Eq1(function (dictEq1) {+ return Data_Eq.eq(eqEither(dictEq)(dictEq1));+ });+};+var ord1Either = function (dictOrd) {+ return new Data_Ord.Ord1(function () {+ return eq1Either(dictOrd.Eq0());+ }, function (dictOrd1) {+ return Data_Ord.compare(ordEither(dictOrd)(dictOrd1));+ });+};+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 230, column 1 - line 230, column 26: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);+ };+ };+};+var isLeft = either(Data_Function["const"](true))(Data_Function["const"](false));+var isRight = either(Data_Function["const"](false))(Data_Function["const"](true));+var choose = function (dictAlt) {+ return function (a) {+ return function (b) {+ return Control_Alt.alt(dictAlt)(Data_Functor.map(dictAlt.Functor0())(Left.create)(a))(Data_Functor.map(dictAlt.Functor0())(Right.create)(b));+ };+ };+};+var boundedEither = function (dictBounded) {+ return function (dictBounded1) {+ return new Data_Bounded.Bounded(function () {+ return ordEither(dictBounded.Ord0())(dictBounded1.Ord0());+ }, new Left(Data_Bounded.bottom(dictBounded)), new Right(Data_Bounded.top(dictBounded1)));+ };+};+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 44, column 3 - line 44, column 34: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);+ };+ };+});+var bifoldableEither = new Data_Bifoldable.Bifoldable(function (dictMonoid) {+ return 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 197, column 3 - line 197, column 31: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);+ };+ };+ };+}, function (v) {+ return function (v1) {+ return function (z) {+ return function (v2) {+ if (v2 instanceof Left) {+ return v(z)(v2.value0);+ };+ if (v2 instanceof Right) {+ return v1(z)(v2.value0);+ };+ throw new Error("Failed pattern match at Data.Either line 195, column 3 - line 195, column 33: " + [ v.constructor.name, v1.constructor.name, z.constructor.name, v2.constructor.name ]);+ };+ };+ };+}, function (v) {+ return function (v1) {+ return function (z) {+ return function (v2) {+ if (v2 instanceof Left) {+ return v(v2.value0)(z);+ };+ if (v2 instanceof Right) {+ return v1(v2.value0)(z);+ };+ throw new Error("Failed pattern match at Data.Either line 193, column 3 - line 193, column 33: " + [ v.constructor.name, v1.constructor.name, z.constructor.name, v2.constructor.name ]);+ };+ };+ };+});+var bitraversableEither = new Data_Bitraversable.Bitraversable(function () {+ return bifoldableEither;+}, function () {+ return bifunctorEither;+}, function (dictApplicative) {+ return function (v) {+ if (v instanceof Left) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Left.create)(v.value0);+ };+ if (v instanceof Right) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Right.create)(v.value0);+ };+ throw new Error("Failed pattern match at Data.Either line 209, column 3 - line 209, column 35: " + [ v.constructor.name ]);+ };+}, function (dictApplicative) {+ return function (v) {+ return function (v1) {+ return function (v2) {+ if (v2 instanceof Left) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Left.create)(v(v2.value0));+ };+ if (v2 instanceof Right) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Right.create)(v1(v2.value0));+ };+ throw new Error("Failed pattern match at Data.Either line 207, column 3 - line 207, column 41: " + [ 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 80, column 3 - line 80, column 28: " + [ v.constructor.name, v1.constructor.name ]);+ };+});+var bindEither = new Control_Bind.Bind(function () {+ return applyEither;+}, either(function (e) {+ return function (v) {+ return new Left(e);+ };+})(function (a) {+ return function (f) {+ return f(a);+ };+}));+var semigroupEither = function (dictSemigroup) {+ return new Data_Semigroup.Semigroup(function (x) {+ return function (y) {+ return Control_Apply.apply(applyEither)(Data_Functor.map(functorEither)(Data_Semigroup.append(dictSemigroup))(x))(y);+ };+ });+};+var semiringEither = function (dictSemiring) {+ return new Data_Semiring.Semiring(function (x) {+ return function (y) {+ return Control_Apply.apply(applyEither)(Data_Functor.map(functorEither)(Data_Semiring.add(dictSemiring))(x))(y);+ };+ }, function (x) {+ return function (y) {+ return Control_Apply.apply(applyEither)(Data_Functor.map(functorEither)(Data_Semiring.mul(dictSemiring))(x))(y);+ };+ }, new Right(Data_Semiring.one(dictSemiring)), new Right(Data_Semiring.zero(dictSemiring)));+};+var applicativeEither = new Control_Applicative.Applicative(function () {+ return applyEither;+}, Right.create);+var monadEither = new Control_Monad.Monad(function () {+ return applicativeEither;+}, function () {+ return bindEither;+});+var altEither = new Control_Alt.Alt(function () {+ return functorEither;+}, function (v) {+ return function (v1) {+ if (v instanceof Left) {+ return v1;+ };+ return v;+ };+});+module.exports = {+ Left: Left, + Right: Right, + choose: choose, + either: either, + fromLeft: fromLeft, + fromRight: fromRight, + isLeft: isLeft, + isRight: isRight, + functorEither: functorEither, + invariantEither: invariantEither, + bifunctorEither: bifunctorEither, + applyEither: applyEither, + applicativeEither: applicativeEither, + altEither: altEither, + bindEither: bindEither, + monadEither: monadEither, + extendEither: extendEither, + showEither: showEither, + eqEither: eqEither, + eq1Either: eq1Either, + ordEither: ordEither, + ord1Either: ord1Either, + boundedEither: boundedEither, + foldableEither: foldableEither, + bifoldableEither: bifoldableEither, + traversableEither: traversableEither, + bitraversableEither: bitraversableEither, + semiringEither: semiringEither, + semigroupEither: semigroupEither+};++},{"../Control.Alt":38,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Extend":49,"../Control.Monad":86,"../Data.Bifoldable":121,"../Data.Bifunctor":127,"../Data.Bitraversable":128,"../Data.Bounded":132,"../Data.Eq":138,"../Data.Foldable":143,"../Data.Function":149,"../Data.Functor":155,"../Data.Functor.Invariant":153,"../Data.Monoid":207,"../Data.Ord":216,"../Data.Ordering":217,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Show":233,"../Data.Traversable":244,"../Prelude":268}],137:[function(require,module,exports){+"use strict";++exports.refEq = function (r1) {+ return function (r2) {+ return r1 === r2;+ };+};++exports.refIneq = function (r1) {+ return function (r2) {+ return r1 !== r2;+ };+};++exports.eqArrayImpl = function (f) {+ return function (xs) {+ return function (ys) {+ if (xs.length !== ys.length) return false;+ for (var i = 0; i < xs.length; i++) {+ if (!f(xs[i])(ys[i])) return false;+ }+ return true;+ };+ };+};++},{}],138:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Data_Unit = require("../Data.Unit");+var Data_Void = require("../Data.Void");+var Eq = function (eq) {+ this.eq = eq;+};+var Eq1 = function (eq1) {+ this.eq1 = eq1;+};+var eqVoid = new Eq(function (v) {+ return function (v1) {+ return true;+ };+});+var eqUnit = new Eq(function (v) {+ return function (v1) {+ return true;+ };+});+var eqString = new Eq($foreign.refEq);+var eqNumber = new Eq($foreign.refEq);+var eqInt = new Eq($foreign.refEq);+var eqChar = new Eq($foreign.refEq);+var eqBoolean = new Eq($foreign.refEq);+var eq1 = function (dict) {+ return dict.eq1;+};+var eq = function (dict) {+ return dict.eq;+};+var eqArray = function (dictEq) {+ return new Eq($foreign.eqArrayImpl(eq(dictEq)));+};+var eq1Array = new Eq1(function (dictEq) {+ return eq(eqArray(dictEq));+});+var notEq = function (dictEq) {+ return function (x) {+ return function (y) {+ return eq(eqBoolean)(eq(dictEq)(x)(y))(false);+ };+ };+};+var notEq1 = function (dictEq1) {+ return function (dictEq) {+ return function (x) {+ return function (y) {+ return eq(eqBoolean)(eq1(dictEq1)(dictEq)(x)(y))(false);+ };+ };+ };+};+module.exports = {+ Eq: Eq, + Eq1: Eq1, + eq: eq, + eq1: eq1, + notEq: notEq, + notEq1: notEq1, + eqBoolean: eqBoolean, + eqInt: eqInt, + eqNumber: eqNumber, + eqChar: eqChar, + eqString: eqString, + eqUnit: eqUnit, + eqVoid: eqVoid, + eqArray: eqArray, + eq1Array: eq1Array+};++},{"../Data.Unit":249,"../Data.Void":250,"./foreign":137}],139:[function(require,module,exports){+"use strict";++exports.intDegree = function (x) {+ return Math.min(Math.abs(x), 2147483647);+};++exports.intDiv = function (x) {+ return function (y) {+ /* jshint bitwise: false */+ return x / y | 0;+ };+};++exports.intMod = function (x) {+ return function (y) {+ return x % y;+ };+};++exports.numDiv = function (n1) {+ return function (n2) {+ return n1 / n2;+ };+};++},{}],140:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Data_BooleanAlgebra = require("../Data.BooleanAlgebra");+var Data_CommutativeRing = require("../Data.CommutativeRing");+var Data_Eq = require("../Data.Eq");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Ring = require("../Data.Ring");+var Data_Semiring = require("../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 gcd = function (__copy_dictEq) {+ return function (__copy_dictEuclideanRing) {+ return function (__copy_a) {+ return function (__copy_b) {+ var dictEq = __copy_dictEq;+ var dictEuclideanRing = __copy_dictEuclideanRing;+ var a = __copy_a;+ var b = __copy_b;+ var __tco_done = false;+ var __tco_result;+ var __tco_dictEq;+ var __tco_dictEuclideanRing;+ var __tco_a;+ var __tco_b;+ function __tco_loop(dictEq, dictEuclideanRing, a, b) {+ var $7 = Data_Eq.eq(dictEq)(b)(Data_Semiring.zero(((dictEuclideanRing.CommutativeRing0()).Ring0()).Semiring0()));+ if ($7) {+ __tco_done = true;+ return a;+ };+ __tco_dictEq = dictEq;+ __tco_dictEuclideanRing = dictEuclideanRing;+ __tco_a = b;+ __tco_b = mod(dictEuclideanRing)(a)(b);+ return;+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(dictEq, dictEuclideanRing, a, b);+ dictEq = __tco_dictEq;+ dictEuclideanRing = __tco_dictEuclideanRing;+ a = __tco_a;+ b = __tco_b;+ };+ return __tco_result;+ };+ };+ };+};+var euclideanRingNumber = new EuclideanRing(function () {+ return Data_CommutativeRing.commutativeRingNumber;+}, function (v) {+ return 1;+}, $foreign.numDiv, function (v) {+ return function (v1) {+ return 0.0;+ };+});+var euclideanRingInt = new EuclideanRing(function () {+ return Data_CommutativeRing.commutativeRingInt;+}, $foreign.intDegree, $foreign.intDiv, $foreign.intMod);+var div = function (dict) {+ return dict.div;+};+var lcm = function (dictEq) {+ return function (dictEuclideanRing) {+ return function (a) {+ return function (b) {+ var $8 = Data_Eq.eq(dictEq)(a)(Data_Semiring.zero(((dictEuclideanRing.CommutativeRing0()).Ring0()).Semiring0())) || Data_Eq.eq(dictEq)(b)(Data_Semiring.zero(((dictEuclideanRing.CommutativeRing0()).Ring0()).Semiring0()));+ if ($8) {+ return Data_Semiring.zero(((dictEuclideanRing.CommutativeRing0()).Ring0()).Semiring0());+ };+ return div(dictEuclideanRing)(Data_Semiring.mul(((dictEuclideanRing.CommutativeRing0()).Ring0()).Semiring0())(a)(b))(gcd(dictEq)(dictEuclideanRing)(a)(b));+ };+ };+ };+};+var degree = function (dict) {+ return dict.degree;+};+module.exports = {+ EuclideanRing: EuclideanRing, + degree: degree, + div: div, + gcd: gcd, + lcm: lcm, + mod: mod, + euclideanRingInt: euclideanRingInt, + euclideanRingNumber: euclideanRingNumber+};++},{"../Data.BooleanAlgebra":130,"../Data.CommutativeRing":133,"../Data.Eq":138,"../Data.HeytingAlgebra":160,"../Data.Ring":227,"../Data.Semiring":231,"./foreign":139}],141:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_CommutativeRing = require("../Data.CommutativeRing");+var Data_EuclideanRing = require("../Data.EuclideanRing");+var Data_Ring = require("../Data.Ring");+var Data_Semiring = require("../Data.Semiring");+var Field = function (EuclideanRing0) {+ this.EuclideanRing0 = EuclideanRing0;+};+var fieldNumber = new Field(function () {+ return Data_EuclideanRing.euclideanRingNumber;+});+module.exports = {+ Field: Field, + fieldNumber: fieldNumber+};++},{"../Data.CommutativeRing":133,"../Data.EuclideanRing":140,"../Data.Ring":227,"../Data.Semiring":231}],142:[function(require,module,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;+ };+ };+};++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;+ };+ };+};++},{}],143:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Alt = require("../Control.Alt");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Category = require("../Control.Category");+var Control_Plus = require("../Control.Plus");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Eq = require("../Data.Eq");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Maybe = require("../Data.Maybe");+var Data_Maybe_First = require("../Data.Maybe.First");+var Data_Maybe_Last = require("../Data.Maybe.Last");+var Data_Monoid = require("../Data.Monoid");+var Data_Monoid_Additive = require("../Data.Monoid.Additive");+var Data_Monoid_Conj = require("../Data.Monoid.Conj");+var Data_Monoid_Disj = require("../Data.Monoid.Disj");+var Data_Monoid_Dual = require("../Data.Monoid.Dual");+var Data_Monoid_Endo = require("../Data.Monoid.Endo");+var Data_Monoid_Multiplicative = require("../Data.Monoid.Multiplicative");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Ordering = require("../Data.Ordering");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var Foldable = function (foldMap, foldl, foldr) {+ this.foldMap = foldMap;+ this.foldl = foldl;+ this.foldr = foldr;+};+var foldr = function (dict) {+ return dict.foldr;+};+var $$null = function (dictFoldable) {+ return foldr(dictFoldable)(function (v) {+ return function (v1) {+ return false;+ };+ })(true);+};+var oneOf = function (dictFoldable) {+ return function (dictPlus) {+ return foldr(dictFoldable)(Control_Alt.alt(dictPlus.Alt0()))(Control_Plus.empty(dictPlus));+ };+};+var traverse_ = function (dictApplicative) {+ return function (dictFoldable) {+ return function (f) {+ return foldr(dictFoldable)(function ($175) {+ return Control_Apply.applySecond(dictApplicative.Apply0())(f($175));+ })(Control_Applicative.pure(dictApplicative)(Data_Unit.unit));+ };+ };+};+var for_ = function (dictApplicative) {+ return function (dictFoldable) {+ return Data_Function.flip(traverse_(dictApplicative)(dictFoldable));+ };+};+var sequence_ = function (dictApplicative) {+ return function (dictFoldable) {+ return traverse_(dictApplicative)(dictFoldable)(Control_Category.id(Control_Category.categoryFn));+ };+};+var foldl = function (dict) {+ return dict.foldl;+};+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 length = function (dictFoldable) {+ return function (dictSemiring) {+ return foldl(dictFoldable)(function (c) {+ return function (v) {+ return Data_Semiring.add(dictSemiring)(Data_Semiring.one(dictSemiring))(c);+ };+ })(Data_Semiring.zero(dictSemiring));+ };+};+var maximumBy = function (dictFoldable) {+ return function (cmp) {+ var max$prime = function (v) {+ return function (v1) {+ if (v instanceof Data_Maybe.Nothing) {+ return new Data_Maybe.Just(v1);+ };+ if (v instanceof Data_Maybe.Just) {+ return new Data_Maybe.Just((function () {+ var $98 = Data_Eq.eq(Data_Ordering.eqOrdering)(cmp(v.value0)(v1))(Data_Ordering.GT.value);+ if ($98) {+ return v.value0;+ };+ return v1;+ })());+ };+ throw new Error("Failed pattern match at Data.Foldable line 296, column 3 - line 296, column 27: " + [ v.constructor.name, v1.constructor.name ]);+ };+ };+ return foldl(dictFoldable)(max$prime)(Data_Maybe.Nothing.value);+ };+};+var maximum = function (dictOrd) {+ return function (dictFoldable) {+ return maximumBy(dictFoldable)(Data_Ord.compare(dictOrd));+ };+};+var minimumBy = function (dictFoldable) {+ return function (cmp) {+ var min$prime = function (v) {+ return function (v1) {+ if (v instanceof Data_Maybe.Nothing) {+ return new Data_Maybe.Just(v1);+ };+ if (v instanceof Data_Maybe.Just) {+ return new Data_Maybe.Just((function () {+ var $102 = Data_Eq.eq(Data_Ordering.eqOrdering)(cmp(v.value0)(v1))(Data_Ordering.LT.value);+ if ($102) {+ return v.value0;+ };+ return v1;+ })());+ };+ throw new Error("Failed pattern match at Data.Foldable line 309, column 3 - line 309, column 27: " + [ v.constructor.name, v1.constructor.name ]);+ };+ };+ return foldl(dictFoldable)(min$prime)(Data_Maybe.Nothing.value);+ };+};+var minimum = function (dictOrd) {+ return function (dictFoldable) {+ return minimumBy(dictFoldable)(Data_Ord.compare(dictOrd));+ };+};+var product = function (dictFoldable) {+ return function (dictSemiring) {+ return foldl(dictFoldable)(Data_Semiring.mul(dictSemiring))(Data_Semiring.one(dictSemiring));+ };+};+var sum = function (dictFoldable) {+ return function (dictSemiring) {+ return foldl(dictFoldable)(Data_Semiring.add(dictSemiring))(Data_Semiring.zero(dictSemiring));+ };+};+var foldableMultiplicative = new Foldable(function (dictMonoid) {+ return function (f) {+ return function (v) {+ return f(v);+ };+ };+}, function (f) {+ return function (z) {+ return function (v) {+ return f(z)(v);+ };+ };+}, function (f) {+ return function (z) {+ return function (v) {+ return f(v)(z);+ };+ };+});+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 130, column 3 - line 130, column 30: " + [ 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 128, column 3 - line 128, column 25: " + [ 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 126, column 3 - line 126, column 25: " + [ v.constructor.name, z.constructor.name, v1.constructor.name ]);+ };+ };+});+var foldableDual = new Foldable(function (dictMonoid) {+ return function (f) {+ return function (v) {+ return f(v);+ };+ };+}, function (f) {+ return function (z) {+ return function (v) {+ return f(z)(v);+ };+ };+}, function (f) {+ return function (z) {+ return function (v) {+ return f(v)(z);+ };+ };+});+var foldableDisj = new Foldable(function (dictMonoid) {+ return function (f) {+ return function (v) {+ return f(v);+ };+ };+}, function (f) {+ return function (z) {+ return function (v) {+ return f(z)(v);+ };+ };+}, function (f) {+ return function (z) {+ return function (v) {+ return f(v)(z);+ };+ };+});+var foldableConj = new Foldable(function (dictMonoid) {+ return function (f) {+ return function (v) {+ return f(v);+ };+ };+}, function (f) {+ return function (z) {+ return function (v) {+ return f(z)(v);+ };+ };+}, function (f) {+ return function (z) {+ return function (v) {+ return f(v)(z);+ };+ };+});+var foldableAdditive = new Foldable(function (dictMonoid) {+ return function (f) {+ return function (v) {+ return f(v);+ };+ };+}, function (f) {+ return function (z) {+ return function (v) {+ return f(z)(v);+ };+ };+}, function (f) {+ return function (z) {+ return function (v) {+ return f(v)(z);+ };+ };+});+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));+ };+ };+};+var foldableArray = new Foldable(function (dictMonoid) {+ return foldMapDefaultR(foldableArray)(dictMonoid);+}, $foreign.foldlArray, $foreign.foldrArray);+var foldMapDefaultL = function (dictFoldable) {+ return function (dictMonoid) {+ return function (f) {+ return foldl(dictFoldable)(function (acc) {+ return function (x) {+ return Data_Semigroup.append(dictMonoid.Semigroup0())(f(x))(acc);+ };+ })(Data_Monoid.mempty(dictMonoid));+ };+ };+};+var foldMap = function (dict) {+ return dict.foldMap;+};+var foldableFirst = new Foldable(function (dictMonoid) {+ return function (f) {+ return function (v) {+ return foldMap(foldableMaybe)(dictMonoid)(f)(v);+ };+ };+}, function (f) {+ return function (z) {+ return function (v) {+ return foldl(foldableMaybe)(f)(z)(v);+ };+ };+}, function (f) {+ return function (z) {+ return function (v) {+ return foldr(foldableMaybe)(f)(z)(v);+ };+ };+});+var foldableLast = new Foldable(function (dictMonoid) {+ return function (f) {+ return function (v) {+ return foldMap(foldableMaybe)(dictMonoid)(f)(v);+ };+ };+}, function (f) {+ return function (z) {+ return function (v) {+ return foldl(foldableMaybe)(f)(z)(v);+ };+ };+}, function (f) {+ return function (z) {+ return function (v) {+ return foldr(foldableMaybe)(f)(z)(v);+ };+ };+});+var foldlDefault = function (dictFoldable) {+ return function (c) {+ return function (u) {+ return function (xs) {+ return Data_Newtype.unwrap(Data_Monoid_Endo.newtypeEndo)(Data_Newtype.unwrap(Data_Monoid_Dual.newtypeDual)(foldMap(dictFoldable)(Data_Monoid_Dual.monoidDual(Data_Monoid_Endo.monoidEndo))(function ($176) {+ return Data_Monoid_Dual.Dual(Data_Monoid_Endo.Endo(Data_Function.flip(c)($176)));+ })(xs)))(u);+ };+ };+ };+};+var foldrDefault = function (dictFoldable) {+ return function (c) {+ return function (u) {+ return function (xs) {+ return Data_Newtype.unwrap(Data_Monoid_Endo.newtypeEndo)(foldMap(dictFoldable)(Data_Monoid_Endo.monoidEndo)(function ($177) {+ return Data_Monoid_Endo.Endo(c($177));+ })(xs))(u);+ };+ };+ };+};+var fold = function (dictFoldable) {+ return function (dictMonoid) {+ return foldMap(dictFoldable)(dictMonoid)(Control_Category.id(Control_Category.categoryFn));+ };+};+var findMap = function (dictFoldable) {+ return function (p) {+ var go = function (v) {+ return function (v1) {+ if (v instanceof Data_Maybe.Nothing) {+ return p(v1);+ };+ return v;+ };+ };+ return foldl(dictFoldable)(go)(Data_Maybe.Nothing.value);+ };+};+var find = function (dictFoldable) {+ return function (p) {+ var go = function (v) {+ return function (v1) {+ if (v instanceof Data_Maybe.Nothing && p(v1)) {+ return new Data_Maybe.Just(v1);+ };+ return v;+ };+ };+ return foldl(dictFoldable)(go)(Data_Maybe.Nothing.value);+ };+};+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 elem = function (dictFoldable) {+ return function (dictEq) {+ return function ($178) {+ return any(dictFoldable)(Data_HeytingAlgebra.heytingAlgebraBoolean)(Data_Eq.eq(dictEq)($178));+ };+ };+};+var notElem = function (dictFoldable) {+ return function (dictEq) {+ return function (x) {+ return function ($179) {+ return !elem(dictFoldable)(dictEq)(x)($179);+ };+ };+ };+};+var or = function (dictFoldable) {+ return function (dictHeytingAlgebra) {+ return any(dictFoldable)(dictHeytingAlgebra)(Control_Category.id(Control_Category.categoryFn));+ };+};+var all = function (dictFoldable) {+ return function (dictHeytingAlgebra) {+ return Data_Newtype.alaF(Data_Functor.functorFn)(Data_Functor.functorFn)(Data_Monoid_Conj.newtypeConj)(Data_Monoid_Conj.newtypeConj)(Data_Monoid_Conj.Conj)(foldMap(dictFoldable)(Data_Monoid_Conj.monoidConj(dictHeytingAlgebra)));+ };+};+var and = function (dictFoldable) {+ return function (dictHeytingAlgebra) {+ return all(dictFoldable)(dictHeytingAlgebra)(Control_Category.id(Control_Category.categoryFn));+ };+};+module.exports = {+ Foldable: Foldable, + all: all, + and: and, + any: any, + elem: elem, + find: find, + findMap: findMap, + fold: fold, + foldMap: foldMap, + foldMapDefaultL: foldMapDefaultL, + foldMapDefaultR: foldMapDefaultR, + foldl: foldl, + foldlDefault: foldlDefault, + foldr: foldr, + foldrDefault: foldrDefault, + for_: for_, + intercalate: intercalate, + length: length, + maximum: maximum, + maximumBy: maximumBy, + minimum: minimum, + minimumBy: minimumBy, + notElem: notElem, + "null": $$null, + oneOf: oneOf, + or: or, + product: product, + sequence_: sequence_, + sum: sum, + traverse_: traverse_, + foldableArray: foldableArray, + foldableMaybe: foldableMaybe, + foldableFirst: foldableFirst, + foldableLast: foldableLast, + foldableAdditive: foldableAdditive, + foldableDual: foldableDual, + foldableDisj: foldableDisj, + foldableConj: foldableConj, + foldableMultiplicative: foldableMultiplicative+};++},{"../Control.Alt":38,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Category":47,"../Control.Plus":91,"../Control.Semigroupoid":92,"../Data.Eq":138,"../Data.Function":149,"../Data.Functor":155,"../Data.HeytingAlgebra":160,"../Data.Maybe":198,"../Data.Maybe.First":196,"../Data.Maybe.Last":197,"../Data.Monoid":207,"../Data.Monoid.Additive":201,"../Data.Monoid.Conj":202,"../Data.Monoid.Disj":203,"../Data.Monoid.Dual":204,"../Data.Monoid.Endo":205,"../Data.Monoid.Multiplicative":206,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Ordering":217,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Unit":249,"../Prelude":268,"./foreign":142}],144:[function(require,module,exports){+"use strict";++exports.toForeign = function (value) {+ return value;+};++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);+};++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]";+};++},{}],145:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Applicative = require("../Control.Applicative");+var Control_Monad_Error_Class = require("../Control.Monad.Error.Class");+var Control_Monad_Except = require("../Control.Monad.Except");+var Control_Monad_Except_Trans = require("../Control.Monad.Except.Trans");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Boolean = require("../Data.Boolean");+var Data_Either = require("../Data.Either");+var Data_Eq = require("../Data.Eq");+var Data_Function = require("../Data.Function");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Identity = require("../Data.Identity");+var Data_Int = require("../Data.Int");+var Data_List_NonEmpty = require("../Data.List.NonEmpty");+var Data_Maybe = require("../Data.Maybe");+var Data_Ord = require("../Data.Ord");+var Data_Ordering = require("../Data.Ordering");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Data_String = require("../Data.String");+var Prelude = require("../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 " + (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 65, column 3 - line 66, column 3: " + [ 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 75, column 1 - line 75, column 44: " + [ v.constructor.name ]);+};+var readUndefined = function (value) {+ if ($foreign.isUndefined(value)) {+ return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_Maybe.Nothing.value);+ };+ if (Data_Boolean.otherwise) {+ return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(new Data_Maybe.Just(value));+ };+ throw new Error("Failed pattern match at Data.Foreign line 156, column 1 - line 158, column 34: " + [ value.constructor.name ]);+};+var readNullOrUndefined = function (value) {+ if ($foreign.isNull(value) || $foreign.isUndefined(value)) {+ return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_Maybe.Nothing.value);+ };+ if (Data_Boolean.otherwise) {+ return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(new Data_Maybe.Just(value));+ };+ throw new Error("Failed pattern match at Data.Foreign line 161, column 1 - line 163, column 34: " + [ value.constructor.name ]);+};+var readNull = function (value) {+ if ($foreign.isNull(value)) {+ return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_Maybe.Nothing.value);+ };+ if (Data_Boolean.otherwise) {+ return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(new Data_Maybe.Just(value));+ };+ throw new Error("Failed pattern match at Data.Foreign line 151, column 1 - line 153, column 34: " + [ value.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 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 Data.Foreign line 146, column 1 - line 148, column 58: " + [ value.constructor.name ]);+};+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 105, column 1 - line 107, column 54: " + [ tag.constructor.name, value.constructor.name ]);+ };+};+var readBoolean = unsafeReadTagged("Boolean");+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 readString = unsafeReadTagged("String");+var readChar = function (value) {+ var error = Data_Either.Left.create(Data_List_NonEmpty.singleton(new TypeMismatch("Char", $foreign.tagOf(value))));+ var fromString = function ($123) {+ return Data_Maybe.maybe(error)(Control_Applicative.pure(Data_Either.applicativeEither))(Data_String.toChar($123));+ };+ return Control_Monad_Except.mapExcept(Data_Either.either(Data_Function["const"](error))(fromString))(readString(value));+};+var eqForeignError = new Data_Eq.Eq(function (x) {+ return function (y) {+ if (x instanceof ForeignError && y instanceof ForeignError) {+ return x.value0 === y.value0;+ };+ if (x instanceof TypeMismatch && y instanceof TypeMismatch) {+ return x.value0 === y.value0 && x.value1 === y.value1;+ };+ if (x instanceof ErrorAtIndex && y instanceof ErrorAtIndex) {+ return x.value0 === y.value0 && Data_Eq.eq(eqForeignError)(x.value1)(y.value1);+ };+ if (x instanceof ErrorAtProperty && y instanceof ErrorAtProperty) {+ return x.value0 === y.value0 && Data_Eq.eq(eqForeignError)(x.value1)(y.value1);+ };+ if (x instanceof JSONError && y instanceof JSONError) {+ return x.value0 === y.value0;+ };+ return false;+ };+});+var ordForeignError = new Data_Ord.Ord(function () {+ return eqForeignError;+}, function (x) {+ return function (y) {+ if (x instanceof ForeignError && y instanceof ForeignError) {+ return Data_Ord.compare(Data_Ord.ordString)(x.value0)(y.value0);+ };+ if (x instanceof ForeignError) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof ForeignError) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof TypeMismatch && y instanceof TypeMismatch) {+ var v = Data_Ord.compare(Data_Ord.ordString)(x.value0)(y.value0);+ if (v instanceof Data_Ordering.LT) {+ return Data_Ordering.LT.value;+ };+ if (v instanceof Data_Ordering.GT) {+ return Data_Ordering.GT.value;+ };+ return Data_Ord.compare(Data_Ord.ordString)(x.value1)(y.value1);+ };+ if (x instanceof TypeMismatch) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof TypeMismatch) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof ErrorAtIndex && y instanceof ErrorAtIndex) {+ var v = Data_Ord.compare(Data_Ord.ordInt)(x.value0)(y.value0);+ if (v instanceof Data_Ordering.LT) {+ return Data_Ordering.LT.value;+ };+ if (v instanceof Data_Ordering.GT) {+ return Data_Ordering.GT.value;+ };+ return Data_Ord.compare(ordForeignError)(x.value1)(y.value1);+ };+ if (x instanceof ErrorAtIndex) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof ErrorAtIndex) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof ErrorAtProperty && y instanceof ErrorAtProperty) {+ var v = Data_Ord.compare(Data_Ord.ordString)(x.value0)(y.value0);+ if (v instanceof Data_Ordering.LT) {+ return Data_Ordering.LT.value;+ };+ if (v instanceof Data_Ordering.GT) {+ return Data_Ordering.GT.value;+ };+ return Data_Ord.compare(ordForeignError)(x.value1)(y.value1);+ };+ if (x instanceof ErrorAtProperty) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof ErrorAtProperty) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof JSONError && y instanceof JSONError) {+ return Data_Ord.compare(Data_Ord.ordString)(x.value0)(y.value0);+ };+ throw new Error("Failed pattern match: " + [ x.constructor.name, y.constructor.name ]);+ };+});+module.exports = {+ ForeignError: ForeignError, + TypeMismatch: TypeMismatch, + ErrorAtIndex: ErrorAtIndex, + ErrorAtProperty: ErrorAtProperty, + JSONError: JSONError, + fail: fail, + readArray: readArray, + readBoolean: readBoolean, + readChar: readChar, + readInt: readInt, + readNull: readNull, + readNullOrUndefined: readNullOrUndefined, + readNumber: readNumber, + readString: readString, + readUndefined: readUndefined, + renderForeignError: renderForeignError, + unsafeReadTagged: unsafeReadTagged, + eqForeignError: eqForeignError, + ordForeignError: ordForeignError, + showForeignError: showForeignError, + isArray: $foreign.isArray, + isNull: $foreign.isNull, + isUndefined: $foreign.isUndefined, + tagOf: $foreign.tagOf, + toForeign: $foreign.toForeign, + typeOf: $foreign.typeOf, + unsafeFromForeign: $foreign.unsafeFromForeign+};++},{"../Control.Applicative":40,"../Control.Monad.Error.Class":71,"../Control.Monad.Except":73,"../Control.Monad.Except.Trans":72,"../Control.Semigroupoid":92,"../Data.Boolean":129,"../Data.Either":136,"../Data.Eq":138,"../Data.Function":149,"../Data.HeytingAlgebra":160,"../Data.Identity":161,"../Data.Int":165,"../Data.List.NonEmpty":192,"../Data.Maybe":198,"../Data.Ord":216,"../Data.Ordering":217,"../Data.Semigroup":229,"../Data.Show":233,"../Data.String":241,"../Prelude":268,"./foreign":144}],146:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Apply = require("../Control.Apply");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Eq = require("../Data.Eq");+var Data_Functor = require("../Data.Functor");+var Data_Generic = require("../Data.Generic");+var Data_Maybe = require("../Data.Maybe");+var Data_Monoid = require("../Data.Monoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Data_String = require("../Data.String");+var Data_Tuple = require("../Data.Tuple");+var Data_Unit = require("../Data.Unit");+var Global = require("../Global");+var Prelude = require("../Prelude");+var FormURLEncoded = function (x) {+ return x;+};+var toArray = function (v) {+ return v;+};+var showFormUrlEncoded = Data_Show.showArray(Data_Tuple.showTuple(Data_Show.showString)(Data_Maybe.showMaybe(Data_Show.showString)));+var semigroupFormUrlEncoded = Data_Semigroup.semigroupArray;+var ordFormUrlEncoded = Data_Ord.ordArray(Data_Tuple.ordTuple(Data_Ord.ordString)(Data_Maybe.ordMaybe(Data_Ord.ordString)));+var newtypeFormUrlEncoded = new Data_Newtype.Newtype(function (n) {+ return n;+}, FormURLEncoded);+var monoidFormUrlEncoded = Data_Monoid.monoidArray;+var genericFormUrlEncoded = new Data_Generic.Generic(function (v) {+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.FormURLEncoded.FormURLEncoded" && v.value1.length === 1)) {+ return Control_Apply.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(FormURLEncoded))(Data_Generic.fromSpine(Data_Generic.genericArray(Data_Generic.genericTuple(Data_Generic.genericString)(Data_Generic.genericMaybe(Data_Generic.genericString))))(v["value1"][0](Data_Unit.unit)));+ };+ return Data_Maybe.Nothing.value;+}, function ($dollarq) {+ return new Data_Generic.SigProd("Data.FormURLEncoded.FormURLEncoded", [ {+ sigConstructor: "Data.FormURLEncoded.FormURLEncoded", + sigValues: [ function ($dollarq1) {+ return Data_Generic.toSignature(Data_Generic.genericArray(Data_Generic.genericTuple(Data_Generic.genericString)(Data_Generic.genericMaybe(Data_Generic.genericString))))(Data_Generic.anyProxy);+ } ]+ } ]);+}, function (v) {+ return new Data_Generic.SProd("Data.FormURLEncoded.FormURLEncoded", [ function ($dollarq) {+ return Data_Generic.toSpine(Data_Generic.genericArray(Data_Generic.genericTuple(Data_Generic.genericString)(Data_Generic.genericMaybe(Data_Generic.genericString))))(v);+ } ]);+});+var fromArray = FormURLEncoded;+var eqFormUrlEncoded = Data_Eq.eqArray(Data_Tuple.eqTuple(Data_Eq.eqString)(Data_Maybe.eqMaybe(Data_Eq.eqString)));+var encode = (function () {+ var encodePart = function (v) {+ if (v.value1 instanceof Data_Maybe.Nothing) {+ return Global["encodeURIComponent"](v.value0);+ };+ if (v.value1 instanceof Data_Maybe.Just) {+ return Global["encodeURIComponent"](v.value0) + ("=" + Global["encodeURIComponent"](v.value1.value0));+ };+ throw new Error("Failed pattern match at Data.FormURLEncoded line 43, column 5 - line 43, column 56: " + [ v.constructor.name ]);+ };+ return function ($21) {+ return Data_String.joinWith("&")(Data_Functor.map(Data_Functor.functorArray)(encodePart)(toArray($21)));+ };+})();+module.exports = {+ FormURLEncoded: FormURLEncoded, + encode: encode, + fromArray: fromArray, + toArray: toArray, + genericFormUrlEncoded: genericFormUrlEncoded, + newtypeFormUrlEncoded: newtypeFormUrlEncoded, + eqFormUrlEncoded: eqFormUrlEncoded, + ordFormUrlEncoded: ordFormUrlEncoded, + showFormUrlEncoded: showFormUrlEncoded, + semigroupFormUrlEncoded: semigroupFormUrlEncoded, + monoidFormUrlEncoded: monoidFormUrlEncoded+};++},{"../Control.Apply":42,"../Control.Semigroupoid":92,"../Data.Eq":138,"../Data.Functor":155,"../Data.Generic":157,"../Data.Maybe":198,"../Data.Monoid":207,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Semigroup":229,"../Data.Show":233,"../Data.String":241,"../Data.Tuple":245,"../Data.Unit":249,"../Global":252,"../Prelude":268}],147:[function(require,module,exports){+"use strict";++// module Data.Function.Uncurried++exports.mkFn0 = function (fn) {+ return function () {+ return fn({});+ };+};++exports.mkFn2 = function (fn) {+ /* jshint maxparams: 2 */+ return function (a, b) {+ return fn(a)(b);+ };+};++exports.mkFn3 = function (fn) {+ /* jshint maxparams: 3 */+ return function (a, b, c) {+ return fn(a)(b)(c);+ };+};++exports.mkFn4 = function (fn) {+ /* jshint maxparams: 4 */+ return function (a, b, c, d) {+ return fn(a)(b)(c)(d);+ };+};++exports.mkFn5 = function (fn) {+ /* jshint maxparams: 5 */+ return function (a, b, c, d, e) {+ return fn(a)(b)(c)(d)(e);+ };+};++exports.mkFn6 = function (fn) {+ /* jshint maxparams: 6 */+ return function (a, b, c, d, e, f) {+ return fn(a)(b)(c)(d)(e)(f);+ };+};++exports.mkFn7 = function (fn) {+ /* jshint maxparams: 7 */+ return function (a, b, c, d, e, f, g) {+ return fn(a)(b)(c)(d)(e)(f)(g);+ };+};++exports.mkFn8 = function (fn) {+ /* jshint maxparams: 8 */+ return function (a, b, c, d, e, f, g, h) {+ return fn(a)(b)(c)(d)(e)(f)(g)(h);+ };+};++exports.mkFn9 = function (fn) {+ /* jshint maxparams: 9 */+ return function (a, b, c, d, e, f, g, h, i) {+ return fn(a)(b)(c)(d)(e)(f)(g)(h)(i);+ };+};++exports.mkFn10 = function (fn) {+ /* jshint maxparams: 10 */+ return function (a, b, c, d, e, f, g, h, i, j) {+ return fn(a)(b)(c)(d)(e)(f)(g)(h)(i)(j);+ };+};++exports.runFn0 = function (fn) {+ return fn();+};++exports.runFn2 = function (fn) {+ return function (a) {+ return function (b) {+ return fn(a, b);+ };+ };+};++exports.runFn3 = function (fn) {+ return function (a) {+ return function (b) {+ return function (c) {+ return fn(a, b, c);+ };+ };+ };+};++exports.runFn4 = function (fn) {+ return function (a) {+ return function (b) {+ return function (c) {+ return function (d) {+ return fn(a, b, c, d);+ };+ };+ };+ };+};++exports.runFn5 = function (fn) {+ return function (a) {+ return function (b) {+ return function (c) {+ return function (d) {+ return function (e) {+ return fn(a, b, c, d, e);+ };+ };+ };+ };+ };+};++exports.runFn6 = function (fn) {+ return function (a) {+ return function (b) {+ return function (c) {+ return function (d) {+ return function (e) {+ return function (f) {+ return fn(a, b, c, d, e, f);+ };+ };+ };+ };+ };+ };+};++exports.runFn7 = function (fn) {+ return function (a) {+ return function (b) {+ return function (c) {+ return function (d) {+ return function (e) {+ return function (f) {+ return function (g) {+ return fn(a, b, c, d, e, f, g);+ };+ };+ };+ };+ };+ };+ };+};++exports.runFn8 = function (fn) {+ return function (a) {+ return function (b) {+ return function (c) {+ return function (d) {+ return function (e) {+ return function (f) {+ return function (g) {+ return function (h) {+ return fn(a, b, c, d, e, f, g, h);+ };+ };+ };+ };+ };+ };+ };+ };+};++exports.runFn9 = function (fn) {+ return function (a) {+ return function (b) {+ return function (c) {+ return function (d) {+ return function (e) {+ return function (f) {+ return function (g) {+ return function (h) {+ return function (i) {+ return fn(a, b, c, d, e, f, g, h, i);+ };+ };+ };+ };+ };+ };+ };+ };+ };+};++exports.runFn10 = function (fn) {+ return function (a) {+ return function (b) {+ return function (c) {+ return function (d) {+ return function (e) {+ return function (f) {+ return function (g) {+ return function (h) {+ return function (i) {+ return function (j) {+ return fn(a, b, c, d, e, f, g, h, i, j);+ };+ };+ };+ };+ };+ };+ };+ };+ };+ };+};++},{}],148:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Data_Unit = require("../Data.Unit");+var runFn1 = function (f) {+ return f;+};+var mkFn1 = function (f) {+ return f;+};+module.exports = {+ mkFn1: mkFn1, + runFn1: runFn1, + mkFn0: $foreign.mkFn0, + mkFn10: $foreign.mkFn10, + mkFn2: $foreign.mkFn2, + mkFn3: $foreign.mkFn3, + mkFn4: $foreign.mkFn4, + mkFn5: $foreign.mkFn5, + mkFn6: $foreign.mkFn6, + mkFn7: $foreign.mkFn7, + mkFn8: $foreign.mkFn8, + mkFn9: $foreign.mkFn9, + runFn0: $foreign.runFn0, + runFn10: $foreign.runFn10, + runFn2: $foreign.runFn2, + runFn3: $foreign.runFn3, + runFn4: $foreign.runFn4, + runFn5: $foreign.runFn5, + runFn6: $foreign.runFn6, + runFn7: $foreign.runFn7, + runFn8: $foreign.runFn8, + runFn9: $foreign.runFn9+};++},{"../Data.Unit":249,"./foreign":147}],149:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var on = function (f) {+ return function (g) {+ return function (x) {+ return function (y) {+ return f(g(x))(g(y));+ };+ };+ };+};+var flip = function (f) {+ return function (b) {+ return function (a) {+ return f(a)(b);+ };+ };+};+var $$const = function (a) {+ return function (v) {+ return a;+ };+};+var applyFlipped = function (x) {+ return function (f) {+ return f(x);+ };+};+var apply = function (f) {+ return function (x) {+ return f(x);+ };+};+module.exports = {+ apply: apply, + applyFlipped: applyFlipped, + "const": $$const, + flip: flip, + on: on+};++},{"../Control.Category":47}],150:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Control_Alternative = require("../Control.Alternative");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Comonad = require("../Control.Comonad");+var Control_Extend = require("../Control.Extend");+var Control_Lazy = require("../Control.Lazy");+var Control_Monad = require("../Control.Monad");+var Control_MonadPlus = require("../Control.MonadPlus");+var Control_Plus = require("../Control.Plus");+var Data_Eq = require("../Data.Eq");+var Data_Foldable = require("../Data.Foldable");+var Data_Functor = require("../Data.Functor");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Data_Traversable = require("../Data.Traversable");+var Prelude = require("../Prelude");+var Unsafe_Coerce = require("../Unsafe.Coerce");+var App = function (x) {+ return x;+};+var traversableApp = function (dictTraversable) {+ return dictTraversable;+};+var showApp = function (dictShow) {+ return new Data_Show.Show(function (v) {+ return "(App " + (Data_Show.show(dictShow)(v) + ")");+ });+};+var plusApp = function (dictPlus) {+ return dictPlus;+};+var newtypeApp = new Data_Newtype.Newtype(function (n) {+ return n;+}, App);+var monadPlusApp = function (dictMonadPlus) {+ return dictMonadPlus;+};+var monadApp = function (dictMonad) {+ return dictMonad;+};+var lazyApp = function (dictLazy) {+ return dictLazy;+};+var hoistLowerApp = Unsafe_Coerce.unsafeCoerce;+var hoistLiftApp = Unsafe_Coerce.unsafeCoerce;+var hoistApp = function (f) {+ return function (v) {+ return f(v);+ };+};+var functorApp = function (dictFunctor) {+ return dictFunctor;+};+var foldableApp = function (dictFoldable) {+ return dictFoldable;+};+var extendApp = function (dictExtend) {+ return dictExtend;+};+var eq1App = function (dictEq1) {+ return new Data_Eq.Eq1(function (dictEq) {+ return function (v) {+ return function (v1) {+ return Data_Eq.eq1(dictEq1)(dictEq)(v)(v1);+ };+ };+ });+};+var eqApp = function (dictEq1) {+ return function (dictEq) {+ return new Data_Eq.Eq(Data_Eq.eq1(eq1App(dictEq1))(dictEq));+ };+};+var ord1App = function (dictOrd1) {+ return new Data_Ord.Ord1(function () {+ return eq1App(dictOrd1.Eq10());+ }, function (dictOrd) {+ return function (v) {+ return function (v1) {+ return Data_Ord.compare1(dictOrd1)(dictOrd)(v)(v1);+ };+ };+ });+};+var ordApp = function (dictOrd1) {+ return function (dictOrd) {+ return new Data_Ord.Ord(function () {+ return eqApp(dictOrd1.Eq10())(dictOrd.Eq0());+ }, Data_Ord.compare1(ord1App(dictOrd1))(dictOrd));+ };+};+var comonadApp = function (dictComonad) {+ return dictComonad;+};+var bindApp = function (dictBind) {+ return dictBind;+};+var applyApp = function (dictApply) {+ return dictApply;+};+var applicativeApp = function (dictApplicative) {+ return dictApplicative;+};+var alternativeApp = function (dictAlternative) {+ return dictAlternative;+};+var altApp = function (dictAlt) {+ return dictAlt;+};+module.exports = {+ App: App, + hoistApp: hoistApp, + hoistLiftApp: hoistLiftApp, + hoistLowerApp: hoistLowerApp, + newtypeApp: newtypeApp, + eqApp: eqApp, + eq1App: eq1App, + ordApp: ordApp, + ord1App: ord1App, + showApp: showApp, + functorApp: functorApp, + applyApp: applyApp, + applicativeApp: applicativeApp, + bindApp: bindApp, + monadApp: monadApp, + altApp: altApp, + plusApp: plusApp, + alternativeApp: alternativeApp, + monadPlusApp: monadPlusApp, + lazyApp: lazyApp, + foldableApp: foldableApp, + traversableApp: traversableApp, + extendApp: extendApp, + comonadApp: comonadApp+};++},{"../Control.Alt":38,"../Control.Alternative":39,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Comonad":48,"../Control.Extend":49,"../Control.Lazy":50,"../Control.Monad":86,"../Control.MonadPlus":87,"../Control.Plus":91,"../Data.Eq":138,"../Data.Foldable":143,"../Data.Functor":155,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Semigroup":229,"../Data.Show":233,"../Data.Traversable":244,"../Prelude":268,"../Unsafe.Coerce":271}],151:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Control_Alternative = require("../Control.Alternative");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Category = require("../Control.Category");+var Control_Plus = require("../Control.Plus");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Eq = require("../Data.Eq");+var Data_Foldable = require("../Data.Foldable");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Functor_App = require("../Data.Functor.App");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Data_Traversable = require("../Data.Traversable");+var Prelude = require("../Prelude");+var Compose = function (x) {+ return x;+};+var showCompose = function (dictShow) {+ return new Data_Show.Show(function (v) {+ return "(Compose " + (Data_Show.show(dictShow)(v) + ")");+ });+};+var newtypeCompose = new Data_Newtype.Newtype(function (n) {+ return n;+}, Compose);+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 foldableCompose = function (dictFoldable) {+ return function (dictFoldable1) {+ return new Data_Foldable.Foldable(function (dictMonoid) {+ return function (f) {+ return function (v) {+ return Data_Foldable.foldMap(dictFoldable)(dictMonoid)(Data_Foldable.foldMap(dictFoldable1)(dictMonoid)(f))(v);+ };+ };+ }, function (f) {+ return function (i) {+ return function (v) {+ return Data_Foldable.foldl(dictFoldable)(Data_Foldable.foldl(dictFoldable1)(f))(i)(v);+ };+ };+ }, function (f) {+ return function (i) {+ return function (v) {+ return Data_Foldable.foldr(dictFoldable)(Data_Function.flip(Data_Foldable.foldr(dictFoldable1)(f)))(i)(v);+ };+ };+ });+ };+};+var traversableCompose = function (dictTraversable) {+ return function (dictTraversable1) {+ return new Data_Traversable.Traversable(function () {+ return foldableCompose(dictTraversable.Foldable1())(dictTraversable1.Foldable1());+ }, function () {+ return functorCompose(dictTraversable.Functor0())(dictTraversable1.Functor0());+ }, function (dictApplicative) {+ return Data_Traversable.traverse(traversableCompose(dictTraversable)(dictTraversable1))(dictApplicative)(Control_Category.id(Control_Category.categoryFn));+ }, function (dictApplicative) {+ return function (f) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Compose)(Data_Traversable.traverse(dictTraversable)(dictApplicative)(Data_Traversable.traverse(dictTraversable1)(dictApplicative)(f))(v));+ };+ };+ });+ };+};+var eq1Compose = function (dictEq1) {+ return function (dictEq11) {+ return new Data_Eq.Eq1(function (dictEq) {+ return function (v) {+ return function (v1) {+ return Data_Eq.eq1(dictEq1)(Data_Functor_App.eqApp(dictEq11)(dictEq))(Data_Functor_App.hoistLiftApp(v))(Data_Functor_App.hoistLiftApp(v1));+ };+ };+ });+ };+};+var eqCompose = function (dictEq1) {+ return function (dictEq11) {+ return function (dictEq) {+ return new Data_Eq.Eq(Data_Eq.eq1(eq1Compose(dictEq1)(dictEq11))(dictEq));+ };+ };+};+var ord1Compose = function (dictOrd1) {+ return function (dictOrd11) {+ return new Data_Ord.Ord1(function () {+ return eq1Compose(dictOrd1.Eq10())(dictOrd11.Eq10());+ }, function (dictOrd) {+ return function (v) {+ return function (v1) {+ return Data_Ord.compare1(dictOrd1)(Data_Functor_App.ordApp(dictOrd11)(dictOrd))(Data_Functor_App.hoistLiftApp(v))(Data_Functor_App.hoistLiftApp(v1));+ };+ };+ });+ };+};+var ordCompose = function (dictOrd1) {+ return function (dictOrd11) {+ return function (dictOrd) {+ return new Data_Ord.Ord(function () {+ return eqCompose(dictOrd1.Eq10())(dictOrd11.Eq10())(dictOrd.Eq0());+ }, Data_Ord.compare1(ord1Compose(dictOrd1)(dictOrd11))(dictOrd));+ };+ };+};+var bihoistCompose = function (dictFunctor) {+ return function (natF) {+ return function (natG) {+ return function (v) {+ return natF(Data_Functor.map(dictFunctor)(natG)(v));+ };+ };+ };+};+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 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)));+ });+ };+};+var altCompose = function (dictAlt) {+ return function (dictFunctor) {+ return new Control_Alt.Alt(function () {+ return functorCompose(dictAlt.Functor0())(dictFunctor);+ }, function (v) {+ return function (v1) {+ return Compose(Control_Alt.alt(dictAlt)(v)(v1));+ };+ });+ };+};+var plusCompose = function (dictPlus) {+ return function (dictFunctor) {+ return new Control_Plus.Plus(function () {+ return altCompose(dictPlus.Alt0())(dictFunctor);+ }, Control_Plus.empty(dictPlus));+ };+};+var alternativeCompose = function (dictAlternative) {+ return function (dictApplicative) {+ return new Control_Alternative.Alternative(function () {+ return applicativeCompose(dictAlternative.Applicative0())(dictApplicative);+ }, function () {+ return plusCompose(dictAlternative.Plus1())((dictApplicative.Apply0()).Functor0());+ });+ };+};+module.exports = {+ Compose: Compose, + bihoistCompose: bihoistCompose, + newtypeCompose: newtypeCompose, + eq1Compose: eq1Compose, + eqCompose: eqCompose, + ord1Compose: ord1Compose, + ordCompose: ordCompose, + showCompose: showCompose, + functorCompose: functorCompose, + applyCompose: applyCompose, + applicativeCompose: applicativeCompose, + foldableCompose: foldableCompose, + traversableCompose: traversableCompose, + altCompose: altCompose, + plusCompose: plusCompose, + alternativeCompose: alternativeCompose+};++},{"../Control.Alt":38,"../Control.Alternative":39,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Category":47,"../Control.Plus":91,"../Control.Semigroupoid":92,"../Data.Eq":138,"../Data.Foldable":143,"../Data.Function":149,"../Data.Functor":155,"../Data.Functor.App":150,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Semigroup":229,"../Data.Show":233,"../Data.Traversable":244,"../Prelude":268}],152:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Functor = require("../Data.Functor");+var Data_Void = require("../Data.Void");+var Prelude = require("../Prelude");+var Contravariant = function (cmap) {+ this.cmap = cmap;+};+var cmap = function (dict) {+ return dict.cmap;+};+var cmapFlipped = function (dictContravariant) {+ return function (x) {+ return function (f) {+ return cmap(dictContravariant)(f)(x);+ };+ };+};+var coerce = function (dictContravariant) {+ return function (dictFunctor) {+ return function (a) {+ return Data_Functor.map(dictFunctor)(Data_Void.absurd)(cmap(dictContravariant)(Data_Void.absurd)(a));+ };+ };+};+module.exports = {+ Contravariant: Contravariant, + cmap: cmap, + cmapFlipped: cmapFlipped, + coerce: coerce+};++},{"../Data.Functor":155,"../Data.Void":250,"../Prelude":268}],153:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Functor = require("../Data.Functor");+var Invariant = function (imap) {+ this.imap = imap;+};+var imapF = function (dictFunctor) {+ return function (f) {+ return function (v) {+ return Data_Functor.map(dictFunctor)(f);+ };+ };+};+var invariantArray = new Invariant(imapF(Data_Functor.functorArray));+var invariantFn = new Invariant(imapF(Data_Functor.functorFn));+var imap = function (dict) {+ return dict.imap;+};+module.exports = {+ Invariant: Invariant, + imap: imap, + imapF: imapF, + invariantFn: invariantFn, + invariantArray: invariantArray+};++},{"../Data.Functor":155}],154:[function(require,module,exports){+"use strict";++exports.arrayMap = function (f) {+ return function (arr) {+ var l = arr.length;+ var result = new Array(l);+ for (var i = 0; i < l; i++) {+ result[i] = f(arr[i]);+ }+ return result;+ };+};++},{}],155:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Function = require("../Data.Function");+var Data_Unit = require("../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 voidLeft = function (dictFunctor) {+ return function (f) {+ return function (x) {+ return map(dictFunctor)(Data_Function["const"](x))(f);+ };+ };+};+var voidRight = function (dictFunctor) {+ return function (x) {+ return map(dictFunctor)(Data_Function["const"](x));+ };+};+var functorFn = new Functor(Control_Semigroupoid.compose(Control_Semigroupoid.semigroupoidFn));+var functorArray = new Functor($foreign.arrayMap);+var flap = function (dictFunctor) {+ return function (ff) {+ return function (x) {+ return map(dictFunctor)(function (f) {+ return f(x);+ })(ff);+ };+ };+};+module.exports = {+ Functor: Functor, + flap: flap, + map: map, + mapFlipped: mapFlipped, + "void": $$void, + voidLeft: voidLeft, + voidRight: voidRight, + functorFn: functorFn, + functorArray: functorArray+};++},{"../Control.Semigroupoid":92,"../Data.Function":149,"../Data.Unit":249,"./foreign":154}],156:[function(require,module,exports){+"use strict";++// module Data.Generic++exports.zipAll = function (f) {+ return function (xs) {+ return function (ys) {+ var l = xs.length < ys.length ? xs.length : ys.length;+ for (var i = 0; i < l; i++) {+ if (!f(xs[i])(ys[i])) {+ return false;+ }+ }+ return true;+ };+ };+};++exports.zipCompare = function (f) {+ return function (xs) {+ return function (ys) {+ var i = 0;+ var xlen = xs.length;+ var ylen = ys.length;+ while (i < xlen && i < ylen) {+ var o = f(xs[i])(ys[i]);+ if (o !== 0) {+ return o;+ }+ i++;+ }+ if (xlen === ylen) {+ return 0;+ } else if (xlen > ylen) {+ return -1;+ } else {+ return 1;+ }+ };+ };+};++},{}],157:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Array = require("../Data.Array");+var Data_Boolean = require("../Data.Boolean");+var Data_Either = require("../Data.Either");+var Data_Eq = require("../Data.Eq");+var Data_Foldable = require("../Data.Foldable");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Identity = require("../Data.Identity");+var Data_List_Types = require("../Data.List.Types");+var Data_Maybe = require("../Data.Maybe");+var Data_Monoid = require("../Data.Monoid");+var Data_NonEmpty = require("../Data.NonEmpty");+var Data_Ord = require("../Data.Ord");+var Data_Ordering = require("../Data.Ordering");+var Data_Ring = require("../Data.Ring");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Data_String = require("../Data.String");+var Data_Traversable = require("../Data.Traversable");+var Data_Tuple = require("../Data.Tuple");+var Data_Unit = require("../Data.Unit");+var Data_Void = require("../Data.Void");+var Prelude = require("../Prelude");+var Type_Proxy = require("../Type.Proxy");+var SProd = (function () {+ function SProd(value0, value1) {+ this.value0 = value0;+ this.value1 = value1;+ };+ SProd.create = function (value0) {+ return function (value1) {+ return new SProd(value0, value1);+ };+ };+ return SProd;+})();+var SRecord = (function () {+ function SRecord(value0) {+ this.value0 = value0;+ };+ SRecord.create = function (value0) {+ return new SRecord(value0);+ };+ return SRecord;+})();+var SNumber = (function () {+ function SNumber(value0) {+ this.value0 = value0;+ };+ SNumber.create = function (value0) {+ return new SNumber(value0);+ };+ return SNumber;+})();+var SBoolean = (function () {+ function SBoolean(value0) {+ this.value0 = value0;+ };+ SBoolean.create = function (value0) {+ return new SBoolean(value0);+ };+ return SBoolean;+})();+var SInt = (function () {+ function SInt(value0) {+ this.value0 = value0;+ };+ SInt.create = function (value0) {+ return new SInt(value0);+ };+ return SInt;+})();+var SString = (function () {+ function SString(value0) {+ this.value0 = value0;+ };+ SString.create = function (value0) {+ return new SString(value0);+ };+ return SString;+})();+var SChar = (function () {+ function SChar(value0) {+ this.value0 = value0;+ };+ SChar.create = function (value0) {+ return new SChar(value0);+ };+ return SChar;+})();+var SArray = (function () {+ function SArray(value0) {+ this.value0 = value0;+ };+ SArray.create = function (value0) {+ return new SArray(value0);+ };+ return SArray;+})();+var SUnit = (function () {+ function SUnit() {++ };+ SUnit.value = new SUnit();+ return SUnit;+})();+var SigProd = (function () {+ function SigProd(value0, value1) {+ this.value0 = value0;+ this.value1 = value1;+ };+ SigProd.create = function (value0) {+ return function (value1) {+ return new SigProd(value0, value1);+ };+ };+ return SigProd;+})();+var SigRecord = (function () {+ function SigRecord(value0) {+ this.value0 = value0;+ };+ SigRecord.create = function (value0) {+ return new SigRecord(value0);+ };+ return SigRecord;+})();+var SigNumber = (function () {+ function SigNumber() {++ };+ SigNumber.value = new SigNumber();+ return SigNumber;+})();+var SigBoolean = (function () {+ function SigBoolean() {++ };+ SigBoolean.value = new SigBoolean();+ return SigBoolean;+})();+var SigInt = (function () {+ function SigInt() {++ };+ SigInt.value = new SigInt();+ return SigInt;+})();+var SigString = (function () {+ function SigString() {++ };+ SigString.value = new SigString();+ return SigString;+})();+var SigChar = (function () {+ function SigChar() {++ };+ SigChar.value = new SigChar();+ return SigChar;+})();+var SigArray = (function () {+ function SigArray(value0) {+ this.value0 = value0;+ };+ SigArray.create = function (value0) {+ return new SigArray(value0);+ };+ return SigArray;+})();+var SigUnit = (function () {+ function SigUnit() {++ };+ SigUnit.value = new SigUnit();+ return SigUnit;+})();+var Generic = function (fromSpine, toSignature, toSpine) {+ this.fromSpine = fromSpine;+ this.toSignature = toSignature;+ this.toSpine = toSpine;+};+var toSpine = function (dict) {+ return dict.toSpine;+};+var toSignature = function (dict) {+ return dict.toSignature;+};+var showSuspended = function (dictShow) {+ return function (e) {+ return "\\_ -> " + Data_Show.show(dictShow)(e(Data_Unit.unit));+ };+};+var showArray = function (v) {+ return function (v1) {+ if (v1.length === 0) {+ return "[]";+ };+ return "[ " + (Data_Foldable.intercalate(Data_Foldable.foldableArray)(Data_Monoid.monoidString)(", ")(Data_Functor.map(Data_Functor.functorArray)(v)(v1)) + " ]");+ };+};+var showGenericSpine = new Data_Show.Show(function (v) {+ if (v instanceof SUnit) {+ return "SUnit";+ };+ if (v instanceof SChar) {+ return "SChar " + Data_Show.show(Data_Show.showChar)(v.value0);+ };+ if (v instanceof SString) {+ return "SString " + Data_Show.show(Data_Show.showString)(v.value0);+ };+ if (v instanceof SBoolean) {+ return "SBoolean " + Data_Show.show(Data_Show.showBoolean)(v.value0);+ };+ if (v instanceof SNumber) {+ return "SNumber " + Data_Show.show(Data_Show.showNumber)(v.value0);+ };+ if (v instanceof SInt) {+ return "SInt " + Data_Show.show(Data_Show.showInt)(v.value0);+ };+ if (v instanceof SArray) {+ return "SArray " + showArray(showSuspended(showGenericSpine))(v.value0);+ };+ if (v instanceof SProd) {+ return "SProd " + (Data_Show.show(Data_Show.showString)(v.value0) + (" " + showArray(showSuspended(showGenericSpine))(v.value1)));+ };+ if (v instanceof SRecord) {+ var showElt = function (v1) {+ return Data_Foldable.fold(Data_Foldable.foldableArray)(Data_Monoid.monoidString)([ "{ recLabel: ", Data_Show.show(Data_Show.showString)(v1.recLabel), ", recValue: ", showSuspended(showGenericSpine)(v1.recValue), " }" ]);+ };+ return "SRecord " + showArray(showElt)(v.value0);+ };+ throw new Error("Failed pattern match at Data.Generic line 272, column 9 - line 273, column 9: " + [ v.constructor.name ]);+});+var orderingToInt = function (v) {+ if (v instanceof Data_Ordering.EQ) {+ return 0;+ };+ if (v instanceof Data_Ordering.LT) {+ return 1;+ };+ if (v instanceof Data_Ordering.GT) {+ return -1 | 0;+ };+ throw new Error("Failed pattern match at Data.Generic line 538, column 17 - line 541, column 10: " + [ v.constructor.name ]);+};+var genericVoid = new Generic(function (v) {+ return Data_Maybe.Nothing.value;+}, function (v) {+ return new SigProd("Data.Void.Void", [ ]);+}, Data_Void.absurd);+var genericUnit = new Generic(function (v) {+ if (v instanceof SUnit) {+ return new Data_Maybe.Just(Data_Unit.unit);+ };+ return Data_Maybe.Nothing.value;+}, function (v) {+ return SigUnit.value;+}, function (v) {+ return SUnit.value;+});+var genericString = new Generic(function (v) {+ if (v instanceof SString) {+ return new Data_Maybe.Just(v.value0);+ };+ return Data_Maybe.Nothing.value;+}, function (v) {+ return SigString.value;+}, SString.create);+var genericOrdering = new Generic(function (v) {+ if (v instanceof SProd && (v.value0 === "Data.Ordering.LT" && v.value1.length === 0)) {+ return new Data_Maybe.Just(Data_Ordering.LT.value);+ };+ if (v instanceof SProd && (v.value0 === "Data.Ordering.EQ" && v.value1.length === 0)) {+ return new Data_Maybe.Just(Data_Ordering.EQ.value);+ };+ if (v instanceof SProd && (v.value0 === "Data.Ordering.GT" && v.value1.length === 0)) {+ return new Data_Maybe.Just(Data_Ordering.GT.value);+ };+ return Data_Maybe.Nothing.value;+}, function (v) {+ return new SigProd("Data.Ordering.Ordering", [ {+ sigConstructor: "Data.Ordering.LT", + sigValues: [ ]+ }, {+ sigConstructor: "Data.Ordering.EQ", + sigValues: [ ]+ }, {+ sigConstructor: "Data.Ordering.GT", + sigValues: [ ]+ } ]);+}, function (v) {+ if (v instanceof Data_Ordering.LT) {+ return new SProd("Data.Ordering.LT", [ ]);+ };+ if (v instanceof Data_Ordering.EQ) {+ return new SProd("Data.Ordering.EQ", [ ]);+ };+ if (v instanceof Data_Ordering.GT) {+ return new SProd("Data.Ordering.GT", [ ]);+ };+ throw new Error("Failed pattern match at Data.Generic line 218, column 13 - line 221, column 38: " + [ v.constructor.name ]);+});+var genericNumber = new Generic(function (v) {+ if (v instanceof SNumber) {+ return new Data_Maybe.Just(v.value0);+ };+ return Data_Maybe.Nothing.value;+}, function (v) {+ return SigNumber.value;+}, SNumber.create);+var genericInt = new Generic(function (v) {+ if (v instanceof SInt) {+ return new Data_Maybe.Just(v.value0);+ };+ return Data_Maybe.Nothing.value;+}, function (v) {+ return SigInt.value;+}, SInt.create);+var genericChar = new Generic(function (v) {+ if (v instanceof SChar) {+ return new Data_Maybe.Just(v.value0);+ };+ return Data_Maybe.Nothing.value;+}, function (v) {+ return SigChar.value;+}, SChar.create);+var genericBool = new Generic(function (v) {+ if (v instanceof SBoolean) {+ return new Data_Maybe.Just(v.value0);+ };+ return Data_Maybe.Nothing.value;+}, function (v) {+ return SigBoolean.value;+}, SBoolean.create);+var fromSpine = function (dict) {+ return dict.fromSpine;+};+var force = function (f) {+ return f(Data_Unit.unit);+};+var genericArray = function (dictGeneric) {+ return new Generic(function (v) {+ if (v instanceof SArray) {+ return Data_Traversable.traverse(Data_Traversable.traversableArray)(Data_Maybe.applicativeMaybe)(function ($310) {+ return fromSpine(dictGeneric)(force($310));+ })(v.value0);+ };+ return Data_Maybe.Nothing.value;+ }, function (x) {+ var lowerProxy = function (v) {+ return Type_Proxy["Proxy"].value;+ };+ return new SigArray(function (v) {+ return toSignature(dictGeneric)(lowerProxy(x));+ });+ }, function ($311) {+ return SArray.create(Data_Functor.map(Data_Functor.functorArray)(function (x) {+ return function (v) {+ return toSpine(dictGeneric)(x);+ };+ })($311));+ });+};+var genericEither = function (dictGeneric) {+ return function (dictGeneric1) {+ return new Generic(function (v) {+ if (v instanceof SProd && (v.value0 === "Data.Either.Left" && v.value1.length === 1)) {+ return Data_Functor.map(Data_Maybe.functorMaybe)(Data_Either.Left.create)(fromSpine(dictGeneric)(force(v["value1"][0])));+ };+ if (v instanceof SProd && (v.value0 === "Data.Either.Right" && v.value1.length === 1)) {+ return Data_Functor.map(Data_Maybe.functorMaybe)(Data_Either.Right.create)(fromSpine(dictGeneric1)(force(v["value1"][0])));+ };+ return Data_Maybe.Nothing.value;+ }, function (x) {+ var rproxy = function (v) {+ return Type_Proxy["Proxy"].value;+ };+ var lproxy = function (v) {+ return Type_Proxy["Proxy"].value;+ };+ return new SigProd("Data.Either.Either", [ {+ sigConstructor: "Data.Either.Left", + sigValues: [ function (v) {+ return toSignature(dictGeneric)(lproxy(x));+ } ]+ }, {+ sigConstructor: "Data.Either.Right", + sigValues: [ function (v) {+ return toSignature(dictGeneric1)(rproxy(x));+ } ]+ } ]);+ }, function (v) {+ if (v instanceof Data_Either.Left) {+ return new SProd("Data.Either.Left", [ function (v1) {+ return toSpine(dictGeneric)(v.value0);+ } ]);+ };+ if (v instanceof Data_Either.Right) {+ return new SProd("Data.Either.Right", [ function (v1) {+ return toSpine(dictGeneric1)(v.value0);+ } ]);+ };+ throw new Error("Failed pattern match at Data.Generic line 181, column 3 - line 181, column 64: " + [ v.constructor.name ]);+ });+ };+};+var genericIdentity = function (dictGeneric) {+ return new Generic(function (v) {+ if (v instanceof SProd && (v.value0 === "Data.Identity.Identity" && v.value1.length === 1)) {+ return Data_Functor.map(Data_Maybe.functorMaybe)(Data_Identity.Identity)(fromSpine(dictGeneric)(force(v["value1"][0])));+ };+ return Data_Maybe.Nothing.value;+ }, function (x) {+ var iproxy = function (v) {+ return Type_Proxy["Proxy"].value;+ };+ return new SigProd("Data.Identity.Identity", [ {+ sigConstructor: "Data.Identity.Identity", + sigValues: [ function (v) {+ return toSignature(dictGeneric)(iproxy(x));+ } ]+ } ]);+ }, function (v) {+ return new SProd("Data.Identity.Identity", [ function (v1) {+ return toSpine(dictGeneric)(v);+ } ]);+ });+};+var genericList = function (dictGeneric) {+ return new Generic(function (v) {+ if (v instanceof SProd && (v.value0 === "Data.List.Types.Cons" && v.value1.length === 2)) {+ return Control_Apply.apply(Data_Maybe.applyMaybe)(Data_Functor.map(Data_Maybe.functorMaybe)(Data_List_Types.Cons.create)(fromSpine(dictGeneric)(force(v["value1"][0]))))(fromSpine(genericList(dictGeneric))(force(v["value1"][1])));+ };+ if (v instanceof SProd && (v.value0 === "Data.List.Types.Nil" && v.value1.length === 0)) {+ return Control_Applicative.pure(Data_Maybe.applicativeMaybe)(Data_List_Types.Nil.value);+ };+ return Data_Maybe.Nothing.value;+ }, function (x) {+ var headProxy = function (v) {+ return Type_Proxy["Proxy"].value;+ };+ return new SigProd("Data.List.Types.List", [ {+ sigConstructor: "Data.List.Types.Cons", + sigValues: [ function (v) {+ return toSignature(dictGeneric)(headProxy(x));+ }, function (v) {+ return toSignature(genericList(dictGeneric))(x);+ } ]+ }, {+ sigConstructor: "Data.List.Types.Nil", + sigValues: [ ]+ } ]);+ }, function (v) {+ if (v instanceof Data_List_Types.Cons) {+ return new SProd("Data.List.Types.Cons", [ function (v1) {+ return toSpine(dictGeneric)(v.value0);+ }, function (v1) {+ return toSpine(genericList(dictGeneric))(v.value1);+ } ]);+ };+ if (v instanceof Data_List_Types.Nil) {+ return new SProd("Data.List.Types.Nil", [ ]);+ };+ throw new Error("Failed pattern match at Data.Generic line 117, column 3 - line 118, column 68: " + [ v.constructor.name ]);+ });+};+var genericMaybe = function (dictGeneric) {+ return new Generic(function (v) {+ if (v instanceof SProd && (v.value0 === "Data.Maybe.Just" && v.value1.length === 1)) {+ return Data_Functor.map(Data_Maybe.functorMaybe)(Data_Maybe.Just.create)(fromSpine(dictGeneric)(force(v["value1"][0])));+ };+ if (v instanceof SProd && (v.value0 === "Data.Maybe.Nothing" && v.value1.length === 0)) {+ return Control_Applicative.pure(Data_Maybe.applicativeMaybe)(Data_Maybe.Nothing.value);+ };+ return Data_Maybe.Nothing.value;+ }, function (x) {+ var mbProxy = function (v) {+ return Type_Proxy["Proxy"].value;+ };+ return new SigProd("Data.Maybe.Maybe", [ {+ sigConstructor: "Data.Maybe.Just", + sigValues: [ function (v) {+ return toSignature(dictGeneric)(mbProxy(x));+ } ]+ }, {+ sigConstructor: "Data.Maybe.Nothing", + sigValues: [ ]+ } ]);+ }, function (v) {+ if (v instanceof Data_Maybe.Just) {+ return new SProd("Data.Maybe.Just", [ function (v1) {+ return toSpine(dictGeneric)(v.value0);+ } ]);+ };+ if (v instanceof Data_Maybe.Nothing) {+ return new SProd("Data.Maybe.Nothing", [ ]);+ };+ throw new Error("Failed pattern match at Data.Generic line 161, column 3 - line 161, column 63: " + [ v.constructor.name ]);+ });+};+var genericNonEmpty = function (dictGeneric) {+ return function (dictGeneric1) {+ return new Generic(function (v) {+ if (v instanceof SProd && (v.value0 === "Data.NonEmpty.NonEmpty" && v.value1.length === 2)) {+ return Control_Apply.apply(Data_Maybe.applyMaybe)(Data_Functor.map(Data_Maybe.functorMaybe)(Data_NonEmpty.NonEmpty.create)(fromSpine(dictGeneric1)(force(v["value1"][0]))))(fromSpine(dictGeneric)(force(v["value1"][1])));+ };+ return Data_Maybe.Nothing.value;+ }, function (x) {+ var tailProxy = function (v) {+ return Type_Proxy["Proxy"].value;+ };+ var headProxy = function (v) {+ return Type_Proxy["Proxy"].value;+ };+ return new SigProd("Data.NonEmpty.NonEmpty", [ {+ sigConstructor: "Data.NonEmpty.NonEmpty", + sigValues: [ function (v) {+ return toSignature(dictGeneric1)(headProxy(x));+ }, function (v) {+ return toSignature(dictGeneric)(tailProxy(x));+ } ]+ } ]);+ }, function (v) {+ return new SProd("Data.NonEmpty.NonEmpty", [ function (v1) {+ return toSpine(dictGeneric1)(v.value0);+ }, function (v1) {+ return toSpine(dictGeneric)(v.value1);+ } ]);+ });+ };+};+var genericNonEmptyList = function (dictGeneric) {+ return new Generic(function (v) {+ if (v instanceof SProd && (v.value0 === "Data.List.Types.NonEmptyList" && v.value1.length === 1)) {+ return Data_Functor.map(Data_Maybe.functorMaybe)(Data_List_Types.NonEmptyList)(fromSpine(genericNonEmpty(genericList(dictGeneric))(dictGeneric))(force(v["value1"][0])));+ };+ return Data_Maybe.Nothing.value;+ }, function (x) {+ var listProxy = function (v) {+ return Type_Proxy["Proxy"].value;+ };+ return new SigProd("Data.List.Types.NonEmptyList", [ {+ sigConstructor: "Data.List.Types.NonEmptyList", + sigValues: [ function (v) {+ return toSignature(genericList(dictGeneric))(listProxy(x));+ } ]+ } ]);+ }, function (v) {+ return new SProd("Data.List.Types.NonEmptyList", [ function (v1) {+ return toSpine(genericNonEmpty(genericList(dictGeneric))(dictGeneric))(v);+ } ]);+ });+};+var genericShowPrec = function (v) {+ return function (v1) {+ if (v1 instanceof SProd) {+ if (Data_Array["null"](v1.value1)) {+ return v1.value0;+ };+ if (Data_Boolean.otherwise) {+ var showParen = function (v2) {+ return function (x) {+ if (!v2) {+ return x;+ };+ if (v2) {+ return "(" + (x + ")");+ };+ throw new Error("Failed pattern match at Data.Generic line 467, column 7 - line 467, column 28: " + [ v2.constructor.name, x.constructor.name ]);+ };+ };+ return showParen(v > 10)(v1.value0 + (" " + Data_String.joinWith(" ")(Data_Functor.map(Data_Functor.functorArray)(function (x) {+ return genericShowPrec(11)(force(x));+ })(v1.value1))));+ };+ };+ if (v1 instanceof SRecord) {+ var showLabelPart = function (x) {+ return x.recLabel + (": " + genericShowPrec(0)(force(x.recValue)));+ };+ return "{" + (Data_String.joinWith(", ")(Data_Functor.map(Data_Functor.functorArray)(showLabelPart)(v1.value0)) + "}");+ };+ if (v1 instanceof SBoolean) {+ return Data_Show.show(Data_Show.showBoolean)(v1.value0);+ };+ if (v1 instanceof SInt) {+ return Data_Show.show(Data_Show.showInt)(v1.value0);+ };+ if (v1 instanceof SNumber) {+ return Data_Show.show(Data_Show.showNumber)(v1.value0);+ };+ if (v1 instanceof SString) {+ return Data_Show.show(Data_Show.showString)(v1.value0);+ };+ if (v1 instanceof SChar) {+ return Data_Show.show(Data_Show.showChar)(v1.value0);+ };+ if (v1 instanceof SArray) {+ return "[" + (Data_String.joinWith(", ")(Data_Functor.map(Data_Functor.functorArray)(function (x) {+ return genericShowPrec(0)(force(x));+ })(v1.value0)) + "]");+ };+ if (v1 instanceof SUnit) {+ return "unit";+ };+ throw new Error("Failed pattern match at Data.Generic line 461, column 1 - line 469, column 1: " + [ v.constructor.name, v1.constructor.name ]);+ };+};+var gShow = function (dictGeneric) {+ return function ($312) {+ return genericShowPrec(0)(toSpine(dictGeneric)($312));+ };+};+var genericTuple = function (dictGeneric) {+ return function (dictGeneric1) {+ return new Generic(function (v) {+ if (v instanceof SProd && (v.value0 === "Data.Tuple.Tuple" && v.value1.length === 2)) {+ return Control_Apply.apply(Data_Maybe.applyMaybe)(Data_Functor.map(Data_Maybe.functorMaybe)(Data_Tuple.Tuple.create)(fromSpine(dictGeneric)(force(v["value1"][0]))))(fromSpine(dictGeneric1)(force(v["value1"][1])));+ };+ return Data_Maybe.Nothing.value;+ }, function (x) {+ var sndProxy = function (v) {+ return Type_Proxy["Proxy"].value;+ };+ var fstProxy = function (v) {+ return Type_Proxy["Proxy"].value;+ };+ return new SigProd("Data.Tuple.Tuple", [ {+ sigConstructor: "Data.Tuple.Tuple", + sigValues: [ function (v) {+ return toSignature(dictGeneric)(fstProxy(x));+ }, function (v) {+ return toSignature(dictGeneric1)(sndProxy(x));+ } ]+ } ]);+ }, function (v) {+ return new SProd("Data.Tuple.Tuple", [ function (v1) {+ return toSpine(dictGeneric)(v.value0);+ }, function (v1) {+ return toSpine(dictGeneric1)(v.value1);+ } ]);+ });+ };+};+var isValidSpine = function (v) {+ return function (v1) {+ if (v instanceof SigBoolean && v1 instanceof SBoolean) {+ return true;+ };+ if (v instanceof SigNumber && v1 instanceof SNumber) {+ return true;+ };+ if (v instanceof SigInt && v1 instanceof SInt) {+ return true;+ };+ if (v instanceof SigString && v1 instanceof SString) {+ return true;+ };+ if (v instanceof SigChar && v1 instanceof SChar) {+ return true;+ };+ if (v instanceof SigArray && v1 instanceof SArray) {+ return Data_Foldable.all(Data_Foldable.foldableArray)(Data_HeytingAlgebra.heytingAlgebraBoolean)(function ($313) {+ return isValidSpine(force(v.value0))(force($313));+ })(v1.value0);+ };+ if (v instanceof SigProd && v1 instanceof SProd) {+ var v2 = Data_Foldable.find(Data_Foldable.foldableArray)(function (alt) {+ return alt.sigConstructor === v1.value0;+ })(v.value1);+ if (v2 instanceof Data_Maybe.Nothing) {+ return false;+ };+ if (v2 instanceof Data_Maybe.Just) {+ return Data_Foldable.and(Data_Foldable.foldableArray)(Data_HeytingAlgebra.heytingAlgebraBoolean)(Data_Array.zipWith(function (sig) {+ return function (spine) {+ return isValidSpine(force(sig))(force(spine));+ };+ })(v2.value0.sigValues)(v1.value1));+ };+ throw new Error("Failed pattern match at Data.Generic line 438, column 3 - line 444, column 15: " + [ v2.constructor.name ]);+ };+ if (v instanceof SigRecord && v1 instanceof SRecord) {+ return Data_Foldable.and(Data_Foldable.foldableArray)(Data_HeytingAlgebra.heytingAlgebraBoolean)(Data_Array.zipWith(function (sig) {+ return function (val) {+ return isValidSpine(force(sig.recValue))(force(val.recValue));+ };+ })(Data_Array.sortBy(function (a) {+ return function (b) {+ return Data_Ord.compare(Data_Ord.ordString)(a.recLabel)(b.recLabel);+ };+ })(v.value0))(Data_Array.sortBy(function (a) {+ return function (b) {+ return Data_Ord.compare(Data_Ord.ordString)(a.recLabel)(b.recLabel);+ };+ })(v1.value0)));+ };+ if (v instanceof SigUnit && v1 instanceof SUnit) {+ return true;+ };+ return false;+ };+};+var showSignature = function (sig) {+ var needsParen = function (s) {+ if (s instanceof SigProd) {+ return true;+ };+ if (s instanceof SigRecord) {+ return true;+ };+ if (s instanceof SigNumber) {+ return false;+ };+ if (s instanceof SigBoolean) {+ return false;+ };+ if (s instanceof SigInt) {+ return false;+ };+ if (s instanceof SigString) {+ return false;+ };+ if (s instanceof SigChar) {+ return false;+ };+ if (s instanceof SigArray) {+ return true;+ };+ if (s instanceof SigUnit) {+ return false;+ };+ throw new Error("Failed pattern match at Data.Generic line 403, column 18 - line 412, column 21: " + [ s.constructor.name ]);+ };+ var paren = function (s) {+ if (needsParen(s)) {+ return "(" + (showSignature(s) + ")");+ };+ if (Data_Boolean.otherwise) {+ return showSignature(s);+ };+ throw new Error("Failed pattern match at Data.Generic line 386, column 3 - line 412, column 21: " + [ s.constructor.name ]);+ };+ return Data_Foldable.fold(Data_Foldable.foldableArray)(Data_Monoid.monoidString)((function () {+ if (sig instanceof SigProd) {+ return [ "SigProd ", Data_Show.show(Data_Show.showString)(sig.value0), " ", showArray(showDataConstructor)(sig.value1) ];+ };+ if (sig instanceof SigRecord) {+ return [ "SigRecord ", showArray(showLabel)(sig.value0) ];+ };+ if (sig instanceof SigNumber) {+ return [ "SigNumber" ];+ };+ if (sig instanceof SigBoolean) {+ return [ "SigBoolean" ];+ };+ if (sig instanceof SigInt) {+ return [ "SigInt" ];+ };+ if (sig instanceof SigString) {+ return [ "SigString" ];+ };+ if (sig instanceof SigChar) {+ return [ "SigChar" ];+ };+ if (sig instanceof SigArray) {+ return [ "SigArray ", paren(force(sig.value0)) ];+ };+ if (sig instanceof SigUnit) {+ return [ "SigUnit" ];+ };+ throw new Error("Failed pattern match at Data.Generic line 386, column 10 - line 396, column 27: " + [ sig.constructor.name ]);+ })());+};+var showLabel = function (l) {+ return "{ recLabel: " + (Data_Show.show(Data_Show.showString)(l.recLabel) + (", recValue: " + (showSignature(force(l.recValue)) + " }")));+};+var showDataConstructor = function (dc) {+ return "{ sigConstructor: " + (Data_Show.show(Data_Show.showString)(dc.sigConstructor) + (", sigValues: " + (showArray(function ($314) {+ return showSignature(force($314));+ })(dc.sigValues) + " }")));+};+var showGenericSignature = new Data_Show.Show(showSignature);+var eqThunk = function (dictEq) {+ return function (x) {+ return function (y) {+ return Data_Eq.eq(dictEq)(force(x))(force(y));+ };+ };+};+var eqRecordSigs = function (dictEq) {+ return function (arr1) {+ return function (arr2) {+ var labelCompare = function (r1) {+ return function (r2) {+ return Data_Ord.compare(Data_Ord.ordString)(r1.recLabel)(r2.recLabel);+ };+ };+ var sorted1 = Data_Array.sortBy(labelCompare)(arr1);+ var sorted2 = Data_Array.sortBy(labelCompare)(arr2);+ var doCmp = function (x) {+ return function (y) {+ return x.recLabel === y.recLabel && Data_Eq.eq(dictEq)(force(x.recValue))(force(y.recValue));+ };+ };+ return Data_Array.length(arr1) === Data_Array.length(arr2) && $foreign.zipAll(doCmp)(sorted1)(sorted2);+ };+ };+};+var eqGenericSpine = new Data_Eq.Eq(function (v) {+ return function (v1) {+ if (v instanceof SProd && v1 instanceof SProd) {+ return v.value0 === v1.value0 && (Data_Array.length(v.value1) === Data_Array.length(v1.value1) && $foreign.zipAll(eqThunk(eqGenericSpine))(v.value1)(v1.value1));+ };+ if (v instanceof SRecord && v1 instanceof SRecord) {+ return eqRecordSigs(eqGenericSpine)(v.value0)(v1.value0);+ };+ if (v instanceof SNumber && v1 instanceof SNumber) {+ return v.value0 === v1.value0;+ };+ if (v instanceof SBoolean && v1 instanceof SBoolean) {+ return v.value0 === v1.value0;+ };+ if (v instanceof SInt && v1 instanceof SInt) {+ return v.value0 === v1.value0;+ };+ if (v instanceof SString && v1 instanceof SString) {+ return v.value0 === v1.value0;+ };+ if (v instanceof SChar && v1 instanceof SChar) {+ return v.value0 === v1.value0;+ };+ if (v instanceof SArray && v1 instanceof SArray) {+ return Data_Array.length(v.value0) === Data_Array.length(v1.value0) && $foreign.zipAll(eqThunk(eqGenericSpine))(v.value0)(v1.value0);+ };+ if (v instanceof SUnit && v1 instanceof SUnit) {+ return true;+ };+ return false;+ };+});+var gEq = function (dictGeneric) {+ return function (x) {+ return function (y) {+ return Data_Eq.eq(eqGenericSpine)(toSpine(dictGeneric)(x))(toSpine(dictGeneric)(y));+ };+ };+};+var eqGenericSignature = new Data_Eq.Eq(function (v) {+ return function (v1) {+ if (v instanceof SigProd && v1 instanceof SigProd) {+ return v.value0 === v1.value0 && (Data_Array.length(v.value1) === Data_Array.length(v1.value1) && $foreign.zipAll(eqDataConstructor)(v.value1)(v1.value1));+ };+ if (v instanceof SigRecord && v1 instanceof SigRecord) {+ return eqRecordSigs(eqGenericSignature)(v.value0)(v1.value0);+ };+ if (v instanceof SigNumber && v1 instanceof SigNumber) {+ return true;+ };+ if (v instanceof SigBoolean && v1 instanceof SigBoolean) {+ return true;+ };+ if (v instanceof SigInt && v1 instanceof SigInt) {+ return true;+ };+ if (v instanceof SigString && v1 instanceof SigString) {+ return true;+ };+ if (v instanceof SigChar && v1 instanceof SigChar) {+ return true;+ };+ if (v instanceof SigArray && v1 instanceof SigArray) {+ return eqThunk(eqGenericSignature)(v.value0)(v1.value0);+ };+ if (v instanceof SigUnit && v1 instanceof SigUnit) {+ return true;+ };+ return false;+ };+});+var eqDataConstructor = function (p1) {+ return function (p2) {+ return p1.sigConstructor === p2.sigConstructor && $foreign.zipAll(eqThunk(eqGenericSignature))(p1.sigValues)(p2.sigValues);+ };+};+var compareThunk = function (dictOrd) {+ return function (x) {+ return function (y) {+ return orderingToInt(Data_Ord.compare(dictOrd)(force(x))(force(y)));+ };+ };+};+var ordGenericSpine = new Data_Ord.Ord(function () {+ return eqGenericSpine;+}, function (v) {+ return function (v1) {+ if (v instanceof SProd && v1 instanceof SProd) {+ var v2 = Data_Ord.compare(Data_Ord.ordString)(v.value0)(v1.value0);+ if (v2 instanceof Data_Ordering.EQ) {+ return Data_Ord.compare(Data_Ord.ordInt)(0)($foreign.zipCompare(compareThunk(ordGenericSpine))(v.value1)(v1.value1));+ };+ return v2;+ };+ if (v instanceof SProd) {+ return Data_Ordering.LT.value;+ };+ if (v1 instanceof SProd) {+ return Data_Ordering.GT.value;+ };+ if (v instanceof SRecord && v1 instanceof SRecord) {+ var go = function (x) {+ return function (y) {+ var v2 = Data_Ord.compare(Data_Ord.ordString)(x.recLabel)(y.recLabel);+ if (v2 instanceof Data_Ordering.EQ) {+ return orderingToInt(Data_Ord.compare(ordGenericSpine)(force(x.recValue))(force(y.recValue)));+ };+ return orderingToInt(v2);+ };+ };+ return Data_Ord.compare(Data_Ord.ordInt)(0)($foreign.zipCompare(go)(v.value0)(v1.value0));+ };+ if (v instanceof SRecord) {+ return Data_Ordering.LT.value;+ };+ if (v1 instanceof SRecord) {+ return Data_Ordering.GT.value;+ };+ if (v instanceof SInt && v1 instanceof SInt) {+ return Data_Ord.compare(Data_Ord.ordInt)(v.value0)(v1.value0);+ };+ if (v instanceof SInt) {+ return Data_Ordering.LT.value;+ };+ if (v1 instanceof SInt) {+ return Data_Ordering.GT.value;+ };+ if (v instanceof SBoolean && v1 instanceof SBoolean) {+ return Data_Ord.compare(Data_Ord.ordBoolean)(v.value0)(v1.value0);+ };+ if (v instanceof SBoolean) {+ return Data_Ordering.LT.value;+ };+ if (v1 instanceof SBoolean) {+ return Data_Ordering.GT.value;+ };+ if (v instanceof SNumber && v1 instanceof SNumber) {+ return Data_Ord.compare(Data_Ord.ordNumber)(v.value0)(v1.value0);+ };+ if (v instanceof SNumber) {+ return Data_Ordering.LT.value;+ };+ if (v1 instanceof SNumber) {+ return Data_Ordering.GT.value;+ };+ if (v instanceof SString && v1 instanceof SString) {+ return Data_Ord.compare(Data_Ord.ordString)(v.value0)(v1.value0);+ };+ if (v instanceof SString) {+ return Data_Ordering.LT.value;+ };+ if (v1 instanceof SString) {+ return Data_Ordering.GT.value;+ };+ if (v instanceof SChar && v1 instanceof SChar) {+ return Data_Ord.compare(Data_Ord.ordChar)(v.value0)(v1.value0);+ };+ if (v instanceof SChar) {+ return Data_Ordering.LT.value;+ };+ if (v1 instanceof SChar) {+ return Data_Ordering.GT.value;+ };+ if (v instanceof SArray && v1 instanceof SArray) {+ return Data_Ord.compare(Data_Ord.ordInt)(0)($foreign.zipCompare(compareThunk(ordGenericSpine))(v.value0)(v1.value0));+ };+ if (v instanceof SArray) {+ return Data_Ordering.LT.value;+ };+ if (v1 instanceof SArray) {+ return Data_Ordering.GT.value;+ };+ if (v instanceof SUnit && v1 instanceof SUnit) {+ return Data_Ordering.EQ.value;+ };+ throw new Error("Failed pattern match at Data.Generic line 304, column 3 - line 307, column 15: " + [ v.constructor.name, v1.constructor.name ]);+ };+});+var gCompare = function (dictGeneric) {+ return function (x) {+ return function (y) {+ return Data_Ord.compare(ordGenericSpine)(toSpine(dictGeneric)(x))(toSpine(dictGeneric)(y));+ };+ };+};+module.exports = {+ SigProd: SigProd, + SigRecord: SigRecord, + SigNumber: SigNumber, + SigBoolean: SigBoolean, + SigInt: SigInt, + SigString: SigString, + SigChar: SigChar, + SigArray: SigArray, + SigUnit: SigUnit, + SProd: SProd, + SRecord: SRecord, + SNumber: SNumber, + SBoolean: SBoolean, + SInt: SInt, + SString: SString, + SChar: SChar, + SArray: SArray, + SUnit: SUnit, + Generic: Generic, + fromSpine: fromSpine, + gCompare: gCompare, + gEq: gEq, + gShow: gShow, + isValidSpine: isValidSpine, + showDataConstructor: showDataConstructor, + showSignature: showSignature, + toSignature: toSignature, + toSpine: toSpine, + genericNumber: genericNumber, + genericInt: genericInt, + genericString: genericString, + genericChar: genericChar, + genericBool: genericBool, + genericArray: genericArray, + genericUnit: genericUnit, + genericVoid: genericVoid, + genericTuple: genericTuple, + genericList: genericList, + genericNonEmptyList: genericNonEmptyList, + genericMaybe: genericMaybe, + genericEither: genericEither, + genericIdentity: genericIdentity, + genericOrdering: genericOrdering, + genericNonEmpty: genericNonEmpty, + showGenericSpine: showGenericSpine, + eqGenericSpine: eqGenericSpine, + ordGenericSpine: ordGenericSpine, + eqGenericSignature: eqGenericSignature, + showGenericSignature: showGenericSignature+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Semigroupoid":92,"../Data.Array":119,"../Data.Boolean":129,"../Data.Either":136,"../Data.Eq":138,"../Data.Foldable":143,"../Data.Function":149,"../Data.Functor":155,"../Data.HeytingAlgebra":160,"../Data.Identity":161,"../Data.List.Types":193,"../Data.Maybe":198,"../Data.Monoid":207,"../Data.NonEmpty":210,"../Data.Ord":216,"../Data.Ordering":217,"../Data.Ring":227,"../Data.Semigroup":229,"../Data.Show":233,"../Data.String":241,"../Data.Traversable":244,"../Data.Tuple":245,"../Data.Unit":249,"../Data.Void":250,"../Prelude":268,"../Type.Proxy":269,"./foreign":156}],158:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Apply = require("../Control.Apply");+var Data_Either = require("../Data.Either");+var Data_Eq = require("../Data.Eq");+var Data_Generic = require("../Data.Generic");+var Data_Maybe = require("../Data.Maybe");+var Data_Ord = require("../Data.Ord");+var Data_Ordering = require("../Data.Ordering");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Data_String = require("../Data.String");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var OPTIONS = (function () {+ function OPTIONS() {++ };+ OPTIONS.value = new OPTIONS();+ return OPTIONS;+})();+var GET = (function () {+ function GET() {++ };+ GET.value = new GET();+ return GET;+})();+var HEAD = (function () {+ function HEAD() {++ };+ HEAD.value = new HEAD();+ return HEAD;+})();+var POST = (function () {+ function POST() {++ };+ POST.value = new POST();+ return POST;+})();+var PUT = (function () {+ function PUT() {++ };+ PUT.value = new PUT();+ return PUT;+})();+var DELETE = (function () {+ function DELETE() {++ };+ DELETE.value = new DELETE();+ return DELETE;+})();+var TRACE = (function () {+ function TRACE() {++ };+ TRACE.value = new TRACE();+ return TRACE;+})();+var CONNECT = (function () {+ function CONNECT() {++ };+ CONNECT.value = new CONNECT();+ return CONNECT;+})();+var PROPFIND = (function () {+ function PROPFIND() {++ };+ PROPFIND.value = new PROPFIND();+ return PROPFIND;+})();+var PROPPATCH = (function () {+ function PROPPATCH() {++ };+ PROPPATCH.value = new PROPPATCH();+ return PROPPATCH;+})();+var MKCOL = (function () {+ function MKCOL() {++ };+ MKCOL.value = new MKCOL();+ return MKCOL;+})();+var COPY = (function () {+ function COPY() {++ };+ COPY.value = new COPY();+ return COPY;+})();+var MOVE = (function () {+ function MOVE() {++ };+ MOVE.value = new MOVE();+ return MOVE;+})();+var LOCK = (function () {+ function LOCK() {++ };+ LOCK.value = new LOCK();+ return LOCK;+})();+var UNLOCK = (function () {+ function UNLOCK() {++ };+ UNLOCK.value = new UNLOCK();+ return UNLOCK;+})();+var PATCH = (function () {+ function PATCH() {++ };+ PATCH.value = new PATCH();+ return PATCH;+})();+var CustomMethod = function (x) {+ return x;+};+var unCustomMethod = function (v) {+ return v;+};+var showMethod = new Data_Show.Show(function (v) {+ if (v instanceof OPTIONS) {+ return "OPTIONS";+ };+ if (v instanceof GET) {+ return "GET";+ };+ if (v instanceof HEAD) {+ return "HEAD";+ };+ if (v instanceof POST) {+ return "POST";+ };+ if (v instanceof PUT) {+ return "PUT";+ };+ if (v instanceof DELETE) {+ return "DELETE";+ };+ if (v instanceof TRACE) {+ return "TRACE";+ };+ if (v instanceof CONNECT) {+ return "CONNECT";+ };+ if (v instanceof PROPFIND) {+ return "PROPFIND";+ };+ if (v instanceof PROPPATCH) {+ return "PROPPATCH";+ };+ if (v instanceof MKCOL) {+ return "MKCOL";+ };+ if (v instanceof COPY) {+ return "COPY";+ };+ if (v instanceof MOVE) {+ return "MOVE";+ };+ if (v instanceof LOCK) {+ return "LOCK";+ };+ if (v instanceof UNLOCK) {+ return "UNLOCK";+ };+ if (v instanceof PATCH) {+ return "PATCH";+ };+ throw new Error("Failed pattern match at Data.HTTP.Method line 43, column 3 - line 44, column 3: " + [ v.constructor.name ]);+});+var showCustomMethod = new Data_Show.Show(function (v) {+ return "(CustomMethod " + (Data_Show.show(Data_Show.showString)(v) + ")");+});+var print = Data_Either.either(Data_Show.show(showMethod))(unCustomMethod);+var genericMethod = new Data_Generic.Generic(function (v) {+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.HTTP.Method.OPTIONS" && v.value1.length === 0)) {+ return new Data_Maybe.Just(OPTIONS.value);+ };+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.HTTP.Method.GET" && v.value1.length === 0)) {+ return new Data_Maybe.Just(GET.value);+ };+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.HTTP.Method.HEAD" && v.value1.length === 0)) {+ return new Data_Maybe.Just(HEAD.value);+ };+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.HTTP.Method.POST" && v.value1.length === 0)) {+ return new Data_Maybe.Just(POST.value);+ };+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.HTTP.Method.PUT" && v.value1.length === 0)) {+ return new Data_Maybe.Just(PUT.value);+ };+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.HTTP.Method.DELETE" && v.value1.length === 0)) {+ return new Data_Maybe.Just(DELETE.value);+ };+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.HTTP.Method.TRACE" && v.value1.length === 0)) {+ return new Data_Maybe.Just(TRACE.value);+ };+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.HTTP.Method.CONNECT" && v.value1.length === 0)) {+ return new Data_Maybe.Just(CONNECT.value);+ };+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.HTTP.Method.PROPFIND" && v.value1.length === 0)) {+ return new Data_Maybe.Just(PROPFIND.value);+ };+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.HTTP.Method.PROPPATCH" && v.value1.length === 0)) {+ return new Data_Maybe.Just(PROPPATCH.value);+ };+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.HTTP.Method.MKCOL" && v.value1.length === 0)) {+ return new Data_Maybe.Just(MKCOL.value);+ };+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.HTTP.Method.COPY" && v.value1.length === 0)) {+ return new Data_Maybe.Just(COPY.value);+ };+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.HTTP.Method.MOVE" && v.value1.length === 0)) {+ return new Data_Maybe.Just(MOVE.value);+ };+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.HTTP.Method.LOCK" && v.value1.length === 0)) {+ return new Data_Maybe.Just(LOCK.value);+ };+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.HTTP.Method.UNLOCK" && v.value1.length === 0)) {+ return new Data_Maybe.Just(UNLOCK.value);+ };+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.HTTP.Method.PATCH" && v.value1.length === 0)) {+ return new Data_Maybe.Just(PATCH.value);+ };+ return Data_Maybe.Nothing.value;+}, function ($dollarq) {+ return new Data_Generic.SigProd("Data.HTTP.Method.Method", [ {+ sigConstructor: "Data.HTTP.Method.OPTIONS", + sigValues: [ ]+ }, {+ sigConstructor: "Data.HTTP.Method.GET", + sigValues: [ ]+ }, {+ sigConstructor: "Data.HTTP.Method.HEAD", + sigValues: [ ]+ }, {+ sigConstructor: "Data.HTTP.Method.POST", + sigValues: [ ]+ }, {+ sigConstructor: "Data.HTTP.Method.PUT", + sigValues: [ ]+ }, {+ sigConstructor: "Data.HTTP.Method.DELETE", + sigValues: [ ]+ }, {+ sigConstructor: "Data.HTTP.Method.TRACE", + sigValues: [ ]+ }, {+ sigConstructor: "Data.HTTP.Method.CONNECT", + sigValues: [ ]+ }, {+ sigConstructor: "Data.HTTP.Method.PROPFIND", + sigValues: [ ]+ }, {+ sigConstructor: "Data.HTTP.Method.PROPPATCH", + sigValues: [ ]+ }, {+ sigConstructor: "Data.HTTP.Method.MKCOL", + sigValues: [ ]+ }, {+ sigConstructor: "Data.HTTP.Method.COPY", + sigValues: [ ]+ }, {+ sigConstructor: "Data.HTTP.Method.MOVE", + sigValues: [ ]+ }, {+ sigConstructor: "Data.HTTP.Method.LOCK", + sigValues: [ ]+ }, {+ sigConstructor: "Data.HTTP.Method.UNLOCK", + sigValues: [ ]+ }, {+ sigConstructor: "Data.HTTP.Method.PATCH", + sigValues: [ ]+ } ]);+}, function (v) {+ if (v instanceof OPTIONS) {+ return new Data_Generic.SProd("Data.HTTP.Method.OPTIONS", [ ]);+ };+ if (v instanceof GET) {+ return new Data_Generic.SProd("Data.HTTP.Method.GET", [ ]);+ };+ if (v instanceof HEAD) {+ return new Data_Generic.SProd("Data.HTTP.Method.HEAD", [ ]);+ };+ if (v instanceof POST) {+ return new Data_Generic.SProd("Data.HTTP.Method.POST", [ ]);+ };+ if (v instanceof PUT) {+ return new Data_Generic.SProd("Data.HTTP.Method.PUT", [ ]);+ };+ if (v instanceof DELETE) {+ return new Data_Generic.SProd("Data.HTTP.Method.DELETE", [ ]);+ };+ if (v instanceof TRACE) {+ return new Data_Generic.SProd("Data.HTTP.Method.TRACE", [ ]);+ };+ if (v instanceof CONNECT) {+ return new Data_Generic.SProd("Data.HTTP.Method.CONNECT", [ ]);+ };+ if (v instanceof PROPFIND) {+ return new Data_Generic.SProd("Data.HTTP.Method.PROPFIND", [ ]);+ };+ if (v instanceof PROPPATCH) {+ return new Data_Generic.SProd("Data.HTTP.Method.PROPPATCH", [ ]);+ };+ if (v instanceof MKCOL) {+ return new Data_Generic.SProd("Data.HTTP.Method.MKCOL", [ ]);+ };+ if (v instanceof COPY) {+ return new Data_Generic.SProd("Data.HTTP.Method.COPY", [ ]);+ };+ if (v instanceof MOVE) {+ return new Data_Generic.SProd("Data.HTTP.Method.MOVE", [ ]);+ };+ if (v instanceof LOCK) {+ return new Data_Generic.SProd("Data.HTTP.Method.LOCK", [ ]);+ };+ if (v instanceof UNLOCK) {+ return new Data_Generic.SProd("Data.HTTP.Method.UNLOCK", [ ]);+ };+ if (v instanceof PATCH) {+ return new Data_Generic.SProd("Data.HTTP.Method.PATCH", [ ]);+ };+ throw new Error("Failed pattern match at Data.HTTP.Method line 40, column 1 - line 40, column 48: " + [ v.constructor.name ]);+});+var genericCustomMethod = new Data_Generic.Generic(function (v) {+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.HTTP.Method.CustomMethod" && v.value1.length === 1)) {+ return Control_Apply.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(CustomMethod))(Data_Generic.fromSpine(Data_Generic.genericString)(v["value1"][0](Data_Unit.unit)));+ };+ return Data_Maybe.Nothing.value;+}, function ($dollarq) {+ return new Data_Generic.SigProd("Data.HTTP.Method.CustomMethod", [ {+ sigConstructor: "Data.HTTP.Method.CustomMethod", + sigValues: [ function ($dollarq1) {+ return Data_Generic.toSignature(Data_Generic.genericString)(Data_Generic.anyProxy);+ } ]+ } ]);+}, function (v) {+ return new Data_Generic.SProd("Data.HTTP.Method.CustomMethod", [ function ($dollarq) {+ return Data_Generic.toSpine(Data_Generic.genericString)(v);+ } ]);+});+var fromString = function (s) {+ var v = Data_String.toUpper(s);+ if (v === "OPTIONS") {+ return new Data_Either.Left(OPTIONS.value);+ };+ if (v === "GET") {+ return new Data_Either.Left(GET.value);+ };+ if (v === "HEAD") {+ return new Data_Either.Left(HEAD.value);+ };+ if (v === "POST") {+ return new Data_Either.Left(POST.value);+ };+ if (v === "PUT") {+ return new Data_Either.Left(PUT.value);+ };+ if (v === "DELETE") {+ return new Data_Either.Left(DELETE.value);+ };+ if (v === "TRACE") {+ return new Data_Either.Left(TRACE.value);+ };+ if (v === "CONNECT") {+ return new Data_Either.Left(CONNECT.value);+ };+ if (v === "PROPFIND") {+ return new Data_Either.Left(PROPFIND.value);+ };+ if (v === "PROPPATCH") {+ return new Data_Either.Left(PROPPATCH.value);+ };+ if (v === "MKCOL") {+ return new Data_Either.Left(MKCOL.value);+ };+ if (v === "COPY") {+ return new Data_Either.Left(COPY.value);+ };+ if (v === "MOVE") {+ return new Data_Either.Left(MOVE.value);+ };+ if (v === "LOCK") {+ return new Data_Either.Left(LOCK.value);+ };+ if (v === "UNLOCK") {+ return new Data_Either.Left(UNLOCK.value);+ };+ return new Data_Either.Right(v);+};+var eqMethod = new Data_Eq.Eq(function (x) {+ return function (y) {+ if (x instanceof OPTIONS && y instanceof OPTIONS) {+ return true;+ };+ if (x instanceof GET && y instanceof GET) {+ return true;+ };+ if (x instanceof HEAD && y instanceof HEAD) {+ return true;+ };+ if (x instanceof POST && y instanceof POST) {+ return true;+ };+ if (x instanceof PUT && y instanceof PUT) {+ return true;+ };+ if (x instanceof DELETE && y instanceof DELETE) {+ return true;+ };+ if (x instanceof TRACE && y instanceof TRACE) {+ return true;+ };+ if (x instanceof CONNECT && y instanceof CONNECT) {+ return true;+ };+ if (x instanceof PROPFIND && y instanceof PROPFIND) {+ return true;+ };+ if (x instanceof PROPPATCH && y instanceof PROPPATCH) {+ return true;+ };+ if (x instanceof MKCOL && y instanceof MKCOL) {+ return true;+ };+ if (x instanceof COPY && y instanceof COPY) {+ return true;+ };+ if (x instanceof MOVE && y instanceof MOVE) {+ return true;+ };+ if (x instanceof LOCK && y instanceof LOCK) {+ return true;+ };+ if (x instanceof UNLOCK && y instanceof UNLOCK) {+ return true;+ };+ if (x instanceof PATCH && y instanceof PATCH) {+ return true;+ };+ return false;+ };+});+var ordMethod = new Data_Ord.Ord(function () {+ return eqMethod;+}, function (x) {+ return function (y) {+ if (x instanceof OPTIONS && y instanceof OPTIONS) {+ return Data_Ordering.EQ.value;+ };+ if (x instanceof OPTIONS) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof OPTIONS) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof GET && y instanceof GET) {+ return Data_Ordering.EQ.value;+ };+ if (x instanceof GET) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof GET) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof HEAD && y instanceof HEAD) {+ return Data_Ordering.EQ.value;+ };+ if (x instanceof HEAD) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof HEAD) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof POST && y instanceof POST) {+ return Data_Ordering.EQ.value;+ };+ if (x instanceof POST) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof POST) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof PUT && y instanceof PUT) {+ return Data_Ordering.EQ.value;+ };+ if (x instanceof PUT) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof PUT) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof DELETE && y instanceof DELETE) {+ return Data_Ordering.EQ.value;+ };+ if (x instanceof DELETE) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof DELETE) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof TRACE && y instanceof TRACE) {+ return Data_Ordering.EQ.value;+ };+ if (x instanceof TRACE) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof TRACE) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof CONNECT && y instanceof CONNECT) {+ return Data_Ordering.EQ.value;+ };+ if (x instanceof CONNECT) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof CONNECT) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof PROPFIND && y instanceof PROPFIND) {+ return Data_Ordering.EQ.value;+ };+ if (x instanceof PROPFIND) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof PROPFIND) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof PROPPATCH && y instanceof PROPPATCH) {+ return Data_Ordering.EQ.value;+ };+ if (x instanceof PROPPATCH) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof PROPPATCH) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof MKCOL && y instanceof MKCOL) {+ return Data_Ordering.EQ.value;+ };+ if (x instanceof MKCOL) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof MKCOL) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof COPY && y instanceof COPY) {+ return Data_Ordering.EQ.value;+ };+ if (x instanceof COPY) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof COPY) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof MOVE && y instanceof MOVE) {+ return Data_Ordering.EQ.value;+ };+ if (x instanceof MOVE) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof MOVE) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof LOCK && y instanceof LOCK) {+ return Data_Ordering.EQ.value;+ };+ if (x instanceof LOCK) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof LOCK) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof UNLOCK && y instanceof UNLOCK) {+ return Data_Ordering.EQ.value;+ };+ if (x instanceof UNLOCK) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof UNLOCK) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof PATCH && y instanceof PATCH) {+ return Data_Ordering.EQ.value;+ };+ throw new Error("Failed pattern match at Data.HTTP.Method line 39, column 1 - line 39, column 40: " + [ x.constructor.name, y.constructor.name ]);+ };+});+var eqCustomMethod = new Data_Eq.Eq(function (x) {+ return function (y) {+ return x === y;+ };+});+var ordCustomMethod = new Data_Ord.Ord(function () {+ return eqCustomMethod;+}, function (x) {+ return function (y) {+ return Data_Ord.compare(Data_Ord.ordString)(x)(y);+ };+});+module.exports = {+ OPTIONS: OPTIONS, + GET: GET, + HEAD: HEAD, + POST: POST, + PUT: PUT, + DELETE: DELETE, + TRACE: TRACE, + CONNECT: CONNECT, + PROPFIND: PROPFIND, + PROPPATCH: PROPPATCH, + MKCOL: MKCOL, + COPY: COPY, + MOVE: MOVE, + LOCK: LOCK, + UNLOCK: UNLOCK, + PATCH: PATCH, + fromString: fromString, + print: print, + unCustomMethod: unCustomMethod, + eqMethod: eqMethod, + ordMethod: ordMethod, + genericMethod: genericMethod, + showMethod: showMethod, + eqCustomMethod: eqCustomMethod, + ordCustomMethod: ordCustomMethod, + genericCustomMethod: genericCustomMethod, + showCustomMethod: showCustomMethod+};++},{"../Control.Apply":42,"../Data.Either":136,"../Data.Eq":138,"../Data.Generic":157,"../Data.Maybe":198,"../Data.Ord":216,"../Data.Ordering":217,"../Data.Semigroup":229,"../Data.Show":233,"../Data.String":241,"../Data.Unit":249,"../Prelude":268}],159:[function(require,module,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;+};++},{}],160:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Data_Unit = require("../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 heytingAlgebraUnit = new HeytingAlgebra(function (v) {+ return function (v1) {+ return Data_Unit.unit;+ };+}, function (v) {+ return function (v1) {+ return Data_Unit.unit;+ };+}, Data_Unit.unit, function (v) {+ return function (v1) {+ return Data_Unit.unit;+ };+}, function (v) {+ return Data_Unit.unit;+}, Data_Unit.unit);+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 heytingAlgebraFunction = function (dictHeytingAlgebra) {+ return new HeytingAlgebra(function (f) {+ return function (g) {+ return function (a) {+ return conj(dictHeytingAlgebra)(f(a))(g(a));+ };+ };+ }, function (f) {+ return function (g) {+ return function (a) {+ return disj(dictHeytingAlgebra)(f(a))(g(a));+ };+ };+ }, function (v) {+ return ff(dictHeytingAlgebra);+ }, function (f) {+ return function (g) {+ return function (a) {+ return implies(dictHeytingAlgebra)(f(a))(g(a));+ };+ };+ }, function (f) {+ return function (a) {+ return not(dictHeytingAlgebra)(f(a));+ };+ }, function (v) {+ return tt(dictHeytingAlgebra);+ });+};+module.exports = {+ HeytingAlgebra: HeytingAlgebra, + conj: conj, + disj: disj, + ff: ff, + implies: implies, + not: not, + tt: tt, + heytingAlgebraBoolean: heytingAlgebraBoolean, + heytingAlgebraUnit: heytingAlgebraUnit, + heytingAlgebraFunction: heytingAlgebraFunction+};++},{"../Data.Unit":249,"./foreign":159}],161:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Comonad = require("../Control.Comonad");+var Control_Extend = require("../Control.Extend");+var Control_Lazy = require("../Control.Lazy");+var Control_Monad = require("../Control.Monad");+var Data_BooleanAlgebra = require("../Data.BooleanAlgebra");+var Data_Bounded = require("../Data.Bounded");+var Data_CommutativeRing = require("../Data.CommutativeRing");+var Data_Eq = require("../Data.Eq");+var Data_EuclideanRing = require("../Data.EuclideanRing");+var Data_Field = require("../Data.Field");+var Data_Foldable = require("../Data.Foldable");+var Data_Functor = require("../Data.Functor");+var Data_Functor_Invariant = require("../Data.Functor.Invariant");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Monoid = require("../Data.Monoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Ring = require("../Data.Ring");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Show = require("../Data.Show");+var Data_Traversable = require("../Data.Traversable");+var Prelude = require("../Prelude");+var Identity = function (x) {+ return x;+};+var showIdentity = function (dictShow) {+ return new Data_Show.Show(function (v) {+ return "(Identity " + (Data_Show.show(dictShow)(v) + ")");+ });+};+var semiringIdentity = function (dictSemiring) {+ return dictSemiring;+};+var semigroupIdenity = function (dictSemigroup) {+ return dictSemigroup;+};+var ringIdentity = function (dictRing) {+ return dictRing;+};+var ordIdentity = function (dictOrd) {+ return dictOrd;+};+var newtypeIdentity = new Data_Newtype.Newtype(function (n) {+ return n;+}, Identity);+var monoidIdentity = function (dictMonoid) {+ return dictMonoid;+};+var lazyIdentity = function (dictLazy) {+ return dictLazy;+};+var heytingAlgebraIdentity = function (dictHeytingAlgebra) {+ return dictHeytingAlgebra;+};+var functorIdentity = new Data_Functor.Functor(function (f) {+ return function (v) {+ return f(v);+ };+});+var invariantIdentity = new Data_Functor_Invariant.Invariant(Data_Functor_Invariant.imapF(functorIdentity));+var foldableIdentity = new Data_Foldable.Foldable(function (dictMonoid) {+ return function (f) {+ return function (v) {+ return f(v);+ };+ };+}, function (f) {+ return function (z) {+ return function (v) {+ return f(z)(v);+ };+ };+}, function (f) {+ return function (z) {+ return function (v) {+ return f(v)(z);+ };+ };+});+var traversableIdentity = new Data_Traversable.Traversable(function () {+ return foldableIdentity;+}, function () {+ return functorIdentity;+}, function (dictApplicative) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Identity)(v);+ };+}, function (dictApplicative) {+ return function (f) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Identity)(f(v));+ };+ };+});+var fieldIdentity = function (dictField) {+ return dictField;+};+var extendIdentity = new Control_Extend.Extend(function () {+ return functorIdentity;+}, function (f) {+ return function (m) {+ return f(m);+ };+});+var euclideanRingIdentity = function (dictEuclideanRing) {+ return dictEuclideanRing;+};+var eqIdentity = function (dictEq) {+ return dictEq;+};+var comonadIdentity = new Control_Comonad.Comonad(function () {+ return extendIdentity;+}, function (v) {+ return v;+});+var commutativeRingIdentity = function (dictCommutativeRing) {+ return dictCommutativeRing;+};+var boundedIdentity = function (dictBounded) {+ return dictBounded;+};+var booleanAlgebraIdentity = function (dictBooleanAlgebra) {+ return dictBooleanAlgebra;+};+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;+});+var altIdentity = new Control_Alt.Alt(function () {+ return functorIdentity;+}, function (x) {+ return function (v) {+ return x;+ };+});+module.exports = {+ Identity: Identity, + newtypeIdentity: newtypeIdentity, + eqIdentity: eqIdentity, + ordIdentity: ordIdentity, + boundedIdentity: boundedIdentity, + heytingAlgebraIdentity: heytingAlgebraIdentity, + booleanAlgebraIdentity: booleanAlgebraIdentity, + semigroupIdenity: semigroupIdenity, + monoidIdentity: monoidIdentity, + semiringIdentity: semiringIdentity, + euclideanRingIdentity: euclideanRingIdentity, + ringIdentity: ringIdentity, + commutativeRingIdentity: commutativeRingIdentity, + fieldIdentity: fieldIdentity, + lazyIdentity: lazyIdentity, + showIdentity: showIdentity, + functorIdentity: functorIdentity, + invariantIdentity: invariantIdentity, + altIdentity: altIdentity, + applyIdentity: applyIdentity, + applicativeIdentity: applicativeIdentity, + bindIdentity: bindIdentity, + monadIdentity: monadIdentity, + extendIdentity: extendIdentity, + comonadIdentity: comonadIdentity, + foldableIdentity: foldableIdentity, + traversableIdentity: traversableIdentity+};++},{"../Control.Alt":38,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Comonad":48,"../Control.Extend":49,"../Control.Lazy":50,"../Control.Monad":86,"../Data.BooleanAlgebra":130,"../Data.Bounded":132,"../Data.CommutativeRing":133,"../Data.Eq":138,"../Data.EuclideanRing":140,"../Data.Field":141,"../Data.Foldable":143,"../Data.Functor":155,"../Data.Functor.Invariant":153,"../Data.HeytingAlgebra":160,"../Data.Monoid":207,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Ring":227,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Show":233,"../Data.Traversable":244,"../Prelude":268}],162:[function(require,module,exports){+"use strict";++// module Data.Int.Bits++exports.and = function (n1) {+ return function (n2) {+ /* jshint bitwise: false */+ return n1 & n2;+ };+};++exports.or = function (n1) {+ return function (n2) {+ /* jshint bitwise: false */+ return n1 | n2;+ };+};++exports.xor = function (n1) {+ return function (n2) {+ /* jshint bitwise: false */+ return n1 ^ n2;+ };+};++exports.shl = function (n1) {+ return function (n2) {+ /* jshint bitwise: false */+ return n1 << n2;+ };+};++exports.shr = function (n1) {+ return function (n2) {+ /* jshint bitwise: false */+ return n1 >> n2;+ };+};++exports.zshr = function (n1) {+ return function (n2) {+ /* jshint bitwise: false */+ return n1 >>> n2;+ };+};++exports.complement = function (n) {+ /* jshint bitwise: false */+ return ~n;+};++},{}],163:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+module.exports = {+ and: $foreign.and, + complement: $foreign.complement, + or: $foreign.or, + shl: $foreign.shl, + shr: $foreign.shr, + xor: $foreign.xor, + zshr: $foreign.zshr+};++},{"./foreign":162}],164:[function(require,module,exports){+"use strict";++// module Data.Int++exports.fromNumberImpl = function (just) {+ return function (nothing) {+ return function (n) {+ /* jshint bitwise: false */+ return (n | 0) === n ? just(n) : nothing;+ };+ };+};++exports.toNumber = function (n) {+ return n;+};++exports.fromStringAsImpl = function (just) {+ return function (nothing) {+ return function (radix) {+ var digits;+ if (radix < 11) {+ digits = "[0-" + (radix - 1).toString() + "]";+ } else if (radix === 11) {+ digits = "[0-9a]";+ } else {+ digits = "[0-9a-" + String.fromCharCode(86 + radix) + "]";+ }+ var pattern = new RegExp("^[\\+\\-]?" + digits + "+$", "i");++ return function (s) {+ /* jshint bitwise: false */+ if (pattern.test(s)) {+ var i = parseInt(s, radix);+ return (i | 0) === i ? just(i) : nothing;+ } else {+ return nothing;+ }+ };+ };+ };+};++exports.toStringAs = function (radix) {+ return function (i) {+ return i.toString(radix);+ };+};++exports.pow = function (x) {+ return function (y) {+ /* jshint bitwise: false */+ return Math.pow(x,y) | 0;+ };+};++},{}],165:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Boolean = require("../Data.Boolean");+var Data_Bounded = require("../Data.Bounded");+var Data_Eq = require("../Data.Eq");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Int_Bits = require("../Data.Int.Bits");+var Data_Maybe = require("../Data.Maybe");+var Data_Ord = require("../Data.Ord");+var Data_Ring = require("../Data.Ring");+var Global = require("../Global");+var $$Math = require("../Math");+var Prelude = require("../Prelude");+var Radix = function (x) {+ return x;+};+var radix = function (n) {+ if (n >= 2 && n <= 36) {+ return new Data_Maybe.Just(n);+ };+ if (Data_Boolean.otherwise) {+ return Data_Maybe.Nothing.value;+ };+ throw new Error("Failed pattern match at Data.Int line 124, column 1 - line 125, column 38: " + [ n.constructor.name ]);+};+var odd = function (x) {+ return (x & 1) !== 0;+};+var octal = 8;+var hexadecimal = 16;+var fromStringAs = $foreign.fromStringAsImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+var fromString = fromStringAs(10);+var fromNumber = $foreign.fromNumberImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+var unsafeClamp = function (x) {+ if (x === Global.infinity) {+ return 0;+ };+ if (x === -Global.infinity) {+ return 0;+ };+ if (x >= $foreign.toNumber(Data_Bounded.top(Data_Bounded.boundedInt))) {+ return Data_Bounded.top(Data_Bounded.boundedInt);+ };+ if (x <= $foreign.toNumber(Data_Bounded.bottom(Data_Bounded.boundedInt))) {+ return Data_Bounded.bottom(Data_Bounded.boundedInt);+ };+ if (Data_Boolean.otherwise) {+ return Data_Maybe.fromMaybe(0)(fromNumber(x));+ };+ throw new Error("Failed pattern match at Data.Int line 63, column 1 - line 68, column 43: " + [ x.constructor.name ]);+};+var round = function ($2) {+ return unsafeClamp($$Math.round($2));+};+var floor = function ($3) {+ return unsafeClamp($$Math.floor($3));+};+var even = function (x) {+ return (x & 1) === 0;+};+var decimal = 10;+var ceil = function ($4) {+ return unsafeClamp($$Math.ceil($4));+};+var binary = 2;+var base36 = 36;+module.exports = {+ base36: base36, + binary: binary, + ceil: ceil, + decimal: decimal, + even: even, + floor: floor, + fromNumber: fromNumber, + fromString: fromString, + fromStringAs: fromStringAs, + hexadecimal: hexadecimal, + octal: octal, + odd: odd, + radix: radix, + round: round, + pow: $foreign.pow, + toNumber: $foreign.toNumber, + toStringAs: $foreign.toStringAs+};++},{"../Control.Semigroupoid":92,"../Data.Boolean":129,"../Data.Bounded":132,"../Data.Eq":138,"../Data.HeytingAlgebra":160,"../Data.Int.Bits":163,"../Data.Maybe":198,"../Data.Ord":216,"../Data.Ring":227,"../Global":252,"../Math":256,"../Prelude":268,"./foreign":164}],166:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Lens_Lens_Tuple = require("../Data.Lens.Lens.Tuple");+var Data_Lens_Lens_Unit = require("../Data.Lens.Lens.Unit");+var Data_Lens_Prism_Either = require("../Data.Lens.Prism.Either");+var Data_Lens_Prism_Maybe = require("../Data.Lens.Prism.Maybe");+module.exports = {};++},{"../Data.Lens.Lens.Tuple":182,"../Data.Lens.Lens.Unit":183,"../Data.Lens.Prism.Either":185,"../Data.Lens.Prism.Maybe":186}],167:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Category = require("../Control.Category");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Either = require("../Data.Either");+var Data_Eq = require("../Data.Eq");+var Data_Foldable = require("../Data.Foldable");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Lens_Internal_Forget = require("../Data.Lens.Internal.Forget");+var Data_Lens_Internal_Indexed = require("../Data.Lens.Internal.Indexed");+var Data_Lens_Types = require("../Data.Lens.Types");+var Data_List = require("../Data.List");+var Data_List_Types = require("../Data.List.Types");+var Data_Maybe = require("../Data.Maybe");+var Data_Maybe_First = require("../Data.Maybe.First");+var Data_Maybe_Last = require("../Data.Maybe.Last");+var Data_Monoid = require("../Data.Monoid");+var Data_Monoid_Additive = require("../Data.Monoid.Additive");+var Data_Monoid_Conj = require("../Data.Monoid.Conj");+var Data_Monoid_Disj = require("../Data.Monoid.Disj");+var Data_Monoid_Dual = require("../Data.Monoid.Dual");+var Data_Monoid_Endo = require("../Data.Monoid.Endo");+var Data_Monoid_Multiplicative = require("../Data.Monoid.Multiplicative");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Profunctor = require("../Data.Profunctor");+var Data_Profunctor_Choice = require("../Data.Profunctor.Choice");+var Data_Ring = require("../Data.Ring");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Tuple = require("../Data.Tuple");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var unfolded = function (dictMonoid) {+ return function (f) {+ return function (p) {+ var go = function ($42) {+ return Data_Maybe.maybe(Data_Monoid.mempty(dictMonoid))(function (v) {+ return Data_Semigroup.append(dictMonoid.Semigroup0())(Data_Newtype.unwrap(Data_Lens_Internal_Forget.newtypeForget)(p)(v.value0))(go(v.value1));+ })(f($42));+ };+ return go;+ };+ };+};+var replicated = function (dictMonoid) {+ return function (i) {+ return function (v) {+ var go = function (v1) {+ return function (x) {+ if (v1 === 0) {+ return Data_Monoid.mempty(Data_Monoid.monoidFn(dictMonoid));+ };+ return Data_Semigroup.append(Data_Semigroup.semigroupFn(dictMonoid.Semigroup0()))(x)(go(v1 - 1 | 0)(x));+ };+ };+ return go(i)(v);+ };+ };+};+var ifoldMapOf = function (p) {+ return function (f) {+ return Data_Newtype.unwrap(Data_Lens_Internal_Forget.newtypeForget)(p(Data_Lens_Internal_Indexed.Indexed(Data_Tuple.uncurry(f))));+ };+};+var ifoldlOf = function (p) {+ return function (f) {+ return function (r) {+ return function ($43) {+ return Data_Function.flip(Data_Newtype.unwrap(Data_Monoid_Endo.newtypeEndo))(r)(Data_Newtype.unwrap(Data_Monoid_Dual.newtypeDual)(ifoldMapOf(p)(function (i) {+ return function ($44) {+ return Data_Monoid_Dual.Dual(Data_Monoid_Endo.Endo(Data_Function.flip(f(i))($44)));+ };+ })($43)));+ };+ };+ };+};+var ifoldrOf = function (p) {+ return function (f) {+ return function (r) {+ return function ($45) {+ return Data_Function.flip(Data_Newtype.unwrap(Data_Monoid_Endo.newtypeEndo))(r)(ifoldMapOf(p)(function (i) {+ return function ($46) {+ return Data_Monoid_Endo.Endo(f(i)($46));+ };+ })($45));+ };+ };+ };+};+var itoListOf = function (p) {+ return ifoldrOf(p)(function (i) {+ return function (x) {+ return function (xs) {+ return new Data_List_Types.Cons(new Data_Tuple.Tuple(i, x), xs);+ };+ };+ })(Data_List_Types.Nil.value);+};+var itraverseOf_ = function (dictApplicative) {+ return function (p) {+ return function (f) {+ return ifoldrOf(p)(function (i) {+ return function (a) {+ return function (fu) {+ return Control_Apply.applySecond(dictApplicative.Apply0())(Data_Functor["void"]((dictApplicative.Apply0()).Functor0())(f(i)(a)))(fu);+ };+ };+ })(Control_Applicative.pure(dictApplicative)(Data_Unit.unit));+ };+ };+};+var ifindOf = function (p) {+ return function (f) {+ return ifoldrOf(p)(function (i) {+ return function (a) {+ return Data_Maybe.maybe((function () {+ var $36 = f(i)(a);+ if ($36) {+ return new Data_Maybe.Just(a);+ };+ return Data_Maybe.Nothing.value;+ })())(Data_Maybe.Just.create);+ };+ })(Data_Maybe.Nothing.value);+ };+};+var ianyOf = function (dictHeytingAlgebra) {+ return function (p) {+ return function (f) {+ return function ($47) {+ return Data_Newtype.unwrap(Data_Monoid_Disj.newtypeDisj)(ifoldMapOf(p)(function (i) {+ return function ($48) {+ return Data_Monoid_Disj.Disj(f(i)($48));+ };+ })($47));+ };+ };+ };+};+var iallOf = function (dictHeytingAlgebra) {+ return function (p) {+ return function (f) {+ return function ($49) {+ return Data_Newtype.unwrap(Data_Monoid_Conj.newtypeConj)(ifoldMapOf(p)(function (i) {+ return function ($50) {+ return Data_Monoid_Conj.Conj(f(i)($50));+ };+ })($49));+ };+ };+ };+};+var folded = function (dictMonoid) {+ return function (dictFoldable) {+ return function (v) {+ return Data_Foldable.foldMap(dictFoldable)(dictMonoid)(v);+ };+ };+};+var foldMapOf = Data_Newtype.under(Data_Lens_Internal_Forget.newtypeForget)(Data_Lens_Internal_Forget.newtypeForget)(Data_Lens_Internal_Forget.Forget);+var foldOf = function (p) {+ return foldMapOf(p)(Control_Category.id(Control_Category.categoryFn));+};+var foldlOf = function (p) {+ return function (f) {+ return function (r) {+ return function ($51) {+ return Data_Function.flip(Data_Newtype.unwrap(Data_Monoid_Endo.newtypeEndo))(r)(Data_Newtype.unwrap(Data_Monoid_Dual.newtypeDual)(foldMapOf(p)(function ($52) {+ return Data_Monoid_Dual.Dual(Data_Monoid_Endo.Endo(Data_Function.flip(f)($52)));+ })($51)));+ };+ };+ };+};+var foldrOf = function (p) {+ return function (f) {+ return function (r) {+ return function ($53) {+ return Data_Function.flip(Data_Newtype.unwrap(Data_Monoid_Endo.newtypeEndo))(r)(foldMapOf(p)(function ($54) {+ return Data_Monoid_Endo.Endo(f($54));+ })($53));+ };+ };+ };+};+var maximumOf = function (dictOrd) {+ return function (p) {+ var max = function (a) {+ return function (b) {+ var $38 = Data_Ord.greaterThan(dictOrd)(a)(b);+ if ($38) {+ return a;+ };+ return b;+ };+ };+ return foldrOf(p)(function (a) {+ return function ($55) {+ return Data_Maybe.Just.create(Data_Maybe.maybe(a)(max(a))($55));+ };+ })(Data_Maybe.Nothing.value);+ };+};+var minimumOf = function (dictOrd) {+ return function (p) {+ var min = function (a) {+ return function (b) {+ var $39 = Data_Ord.lessThan(dictOrd)(a)(b);+ if ($39) {+ return a;+ };+ return b;+ };+ };+ return foldrOf(p)(function (a) {+ return function ($56) {+ return Data_Maybe.Just.create(Data_Maybe.maybe(a)(min(a))($56));+ };+ })(Data_Maybe.Nothing.value);+ };+};+var toListOf = function (p) {+ return foldrOf(p)(Data_List_Types.Cons.create)(Data_List_Types.Nil.value);+};+var toListOfOn = function (s) {+ return function (p) {+ return toListOf(p)(s);+ };+};+var traverseOf_ = function (dictApplicative) {+ return function (p) {+ return function (f) {+ return foldrOf(p)(function (a) {+ return function (fu) {+ return Control_Apply.applySecond(dictApplicative.Apply0())(Data_Functor["void"]((dictApplicative.Apply0()).Functor0())(f(a)))(fu);+ };+ })(Control_Applicative.pure(dictApplicative)(Data_Unit.unit));+ };+ };+};+var has = function (dictHeytingAlgebra) {+ return function (p) {+ return function ($57) {+ return Data_Newtype.unwrap(Data_Monoid_Disj.newtypeDisj)(foldMapOf(p)(Data_Function["const"](Data_HeytingAlgebra.tt(dictHeytingAlgebra)))($57));+ };+ };+};+var hasn$primet = function (dictHeytingAlgebra) {+ return function (p) {+ return function ($58) {+ return Data_Newtype.unwrap(Data_Monoid_Conj.newtypeConj)(foldMapOf(p)(Data_Function["const"](Data_HeytingAlgebra.ff(dictHeytingAlgebra)))($58));+ };+ };+};+var lastOf = function (p) {+ return function ($59) {+ return Data_Newtype.unwrap(Data_Maybe_Last.newtypeLast)(foldMapOf(p)(function ($60) {+ return Data_Maybe_Last.Last(Data_Maybe.Just.create($60));+ })($59));+ };+};+var lengthOf = function (p) {+ return function ($61) {+ return Data_Newtype.unwrap(Data_Monoid_Additive.newtypeAdditive)(foldMapOf(p)(Data_Function["const"](1))($61));+ };+};+var preview = function (p) {+ return function ($62) {+ return Data_Newtype.unwrap(Data_Maybe_First.newtypeFirst)(foldMapOf(p)(function ($63) {+ return Data_Maybe_First.First(Data_Maybe.Just.create($63));+ })($62));+ };+};+var previewOn = function (s) {+ return function (p) {+ return preview(p)(s);+ };+};+var productOf = function (dictSemiring) {+ return function (p) {+ return function ($64) {+ return Data_Newtype.unwrap(Data_Monoid_Multiplicative.newtypeMultiplicative)(foldMapOf(p)(Data_Monoid_Multiplicative.Multiplicative)($64));+ };+ };+};+var sequenceOf_ = function (dictApplicative) {+ return function (p) {+ return function ($65) {+ return Data_Function.flip(Data_Newtype.unwrap(Data_Monoid_Endo.newtypeEndo))(Control_Applicative.pure(dictApplicative)(Data_Unit.unit))(foldMapOf(p)(function (f) {+ return function (v) {+ return Control_Apply.applySecond(dictApplicative.Apply0())(f)(v);+ };+ })($65));+ };+ };+};+var sumOf = function (dictSemiring) {+ return function (p) {+ return function ($66) {+ return Data_Newtype.unwrap(Data_Monoid_Additive.newtypeAdditive)(foldMapOf(p)(Data_Monoid_Additive.Additive)($66));+ };+ };+};+var firstOf = function (p) {+ return function ($67) {+ return Data_Newtype.unwrap(Data_Maybe_First.newtypeFirst)(foldMapOf(p)(function ($68) {+ return Data_Maybe_First.First(Data_Maybe.Just.create($68));+ })($67));+ };+};+var findOf = function (p) {+ return function (f) {+ return foldrOf(p)(function (a) {+ return Data_Maybe.maybe((function () {+ var $40 = f(a);+ if ($40) {+ return new Data_Maybe.Just(a);+ };+ return Data_Maybe.Nothing.value;+ })())(Data_Maybe.Just.create);+ })(Data_Maybe.Nothing.value);+ };+};+var filtered = function (dictChoice) {+ return function (f) {+ return function ($69) {+ return Data_Profunctor.dimap(dictChoice.Profunctor0())(function (x) {+ var $41 = f(x);+ if ($41) {+ return new Data_Either.Right(x);+ };+ return new Data_Either.Left(x);+ })(Data_Either.either(Control_Category.id(Control_Category.categoryFn))(Control_Category.id(Control_Category.categoryFn)))(Data_Profunctor_Choice.right(dictChoice)($69));+ };+ };+};+var anyOf = function (dictHeytingAlgebra) {+ return function (p) {+ return function (f) {+ return function ($70) {+ return Data_Newtype.unwrap(Data_Monoid_Disj.newtypeDisj)(foldMapOf(p)(function ($71) {+ return Data_Monoid_Disj.Disj(f($71));+ })($70));+ };+ };+ };+};+var elemOf = function (dictEq) {+ return function (p) {+ return function (a) {+ return anyOf(Data_HeytingAlgebra.heytingAlgebraBoolean)(p)(function (v) {+ return Data_Eq.eq(dictEq)(v)(a);+ });+ };+ };+};+var orOf = function (dictHeytingAlgebra) {+ return function (p) {+ return anyOf(dictHeytingAlgebra)(p)(Control_Category.id(Control_Category.categoryFn));+ };+};+var allOf = function (dictHeytingAlgebra) {+ return function (p) {+ return function (f) {+ return function ($72) {+ return Data_Newtype.unwrap(Data_Monoid_Conj.newtypeConj)(foldMapOf(p)(function ($73) {+ return Data_Monoid_Conj.Conj(f($73));+ })($72));+ };+ };+ };+};+var andOf = function (dictHeytingAlgebra) {+ return function (p) {+ return allOf(dictHeytingAlgebra)(p)(Control_Category.id(Control_Category.categoryFn));+ };+};+var notElemOf = function (dictEq) {+ return function (p) {+ return function (a) {+ return allOf(Data_HeytingAlgebra.heytingAlgebraBoolean)(p)(function (v) {+ return Data_Eq.notEq(dictEq)(v)(a);+ });+ };+ };+};+module.exports = {+ allOf: allOf, + andOf: andOf, + anyOf: anyOf, + elemOf: elemOf, + filtered: filtered, + findOf: findOf, + firstOf: firstOf, + foldMapOf: foldMapOf, + foldOf: foldOf, + folded: folded, + foldlOf: foldlOf, + foldrOf: foldrOf, + has: has, + "hasn't": hasn$primet, + iallOf: iallOf, + ianyOf: ianyOf, + ifoldMapOf: ifoldMapOf, + ifoldlOf: ifoldlOf, + ifoldrOf: ifoldrOf, + itoListOf: itoListOf, + itraverseOf_: itraverseOf_, + lastOf: lastOf, + lengthOf: lengthOf, + maximumOf: maximumOf, + minimumOf: minimumOf, + notElemOf: notElemOf, + orOf: orOf, + preview: preview, + previewOn: previewOn, + productOf: productOf, + replicated: replicated, + sequenceOf_: sequenceOf_, + sumOf: sumOf, + toListOf: toListOf, + toListOfOn: toListOfOn, + traverseOf_: traverseOf_, + unfolded: unfolded+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Category":47,"../Control.Semigroupoid":92,"../Data.Either":136,"../Data.Eq":138,"../Data.Foldable":143,"../Data.Function":149,"../Data.Functor":155,"../Data.HeytingAlgebra":160,"../Data.Lens.Internal.Forget":172,"../Data.Lens.Internal.Indexed":174,"../Data.Lens.Types":190,"../Data.List":194,"../Data.List.Types":193,"../Data.Maybe":198,"../Data.Maybe.First":196,"../Data.Maybe.Last":197,"../Data.Monoid":207,"../Data.Monoid.Additive":201,"../Data.Monoid.Conj":202,"../Data.Monoid.Disj":203,"../Data.Monoid.Dual":204,"../Data.Monoid.Endo":205,"../Data.Monoid.Multiplicative":206,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Profunctor":225,"../Data.Profunctor.Choice":218,"../Data.Ring":227,"../Data.Semigroup":229,"../Data.Tuple":245,"../Data.Unit":249,"../Prelude":268}],168:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var Control_Monad_State_Class = require("../Control.Monad.State.Class");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Function = require("../Data.Function");+var Data_Lens_Internal_Forget = require("../Data.Lens.Internal.Forget");+var Data_Lens_Internal_Indexed = require("../Data.Lens.Internal.Indexed");+var Data_Lens_Types = require("../Data.Lens.Types");+var Data_Newtype = require("../Data.Newtype");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var view = function (l) {+ return Data_Newtype.unwrap(Data_Lens_Internal_Forget.newtypeForget)(l(Control_Category.id(Control_Category.categoryFn)));+};+var viewOn = function (s) {+ return function (l) {+ return view(l)(s);+ };+};+var use = function (dictMonadState) {+ return function (p) {+ return Control_Monad_State_Class.gets(dictMonadState)(function (v) {+ return viewOn(v)(p);+ });+ };+};+var to = function (f) {+ return function (p) {+ return function ($3) {+ return Data_Newtype.unwrap(Data_Lens_Internal_Forget.newtypeForget)(p)(f($3));+ };+ };+};+var iview = function (l) {+ return Data_Newtype.unwrap(Data_Lens_Internal_Forget.newtypeForget)(l(Data_Lens_Internal_Indexed.Indexed(Control_Category.id(Control_Category.categoryFn))));+};+var iuse = function (dictMonadState) {+ return function (p) {+ return Control_Monad_State_Class.gets(dictMonadState)(iview(p));+ };+};+module.exports = {+ iuse: iuse, + iview: iview, + to: to, + use: use, + view: view, + viewOn: viewOn+};++},{"../Control.Category":47,"../Control.Monad.State.Class":80,"../Control.Semigroupoid":92,"../Data.Function":149,"../Data.Lens.Internal.Forget":172,"../Data.Lens.Internal.Indexed":174,"../Data.Lens.Types":190,"../Data.Newtype":209,"../Data.Tuple":245,"../Prelude":268}],169:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var Data_Distributive = require("../Data.Distributive");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Lens_Internal_Grating = require("../Data.Lens.Internal.Grating");+var Data_Lens_Internal_Zipping = require("../Data.Lens.Internal.Zipping");+var Data_Lens_Types = require("../Data.Lens.Types");+var Data_Newtype = require("../Data.Newtype");+var Data_Profunctor = require("../Data.Profunctor");+var Data_Profunctor_Closed = require("../Data.Profunctor.Closed");+var Data_Profunctor_Costar = require("../Data.Profunctor.Costar");+var Data_Profunctor_Star = require("../Data.Profunctor.Star");+var Prelude = require("../Prelude");+var zipWithOf = function (g) {+ return function (f) {+ return Data_Newtype.unwrap(Data_Lens_Internal_Zipping.newtypeZipping)(g(f));+ };+};+var zipFWithOf = function (g) {+ return function (f) {+ return Data_Newtype.unwrap(Data_Profunctor_Costar.newtypeCostar)(g(f));+ };+};+var withGrate = function (g) {+ return Data_Newtype.unwrap(Data_Lens_Internal_Grating.newtypeGrating)(g(function (f) {+ return f(Control_Category.id(Control_Category.categoryFn));+ }));+};+var grate = function (f) {+ return function (dictClosed) {+ return function (pab) {+ return Data_Profunctor.dimap(dictClosed.Profunctor0())(Data_Function.applyFlipped)(f)(Data_Profunctor_Closed.closed(dictClosed)(pab));+ };+ };+};+var cotraversed = function (dictDistributive) {+ return function (dictClosed) {+ return grate(function (f) {+ return Data_Distributive.cotraverse(dictDistributive)(Data_Functor.functorFn)(f)(Control_Category.id(Control_Category.categoryFn));+ })(dictClosed);+ };+};+var collectOf = function (g) {+ return function (f) {+ return Data_Newtype.unwrap(Data_Profunctor_Star.newtypeStar)(g(f));+ };+};+var cloneGrate = function (g) {+ return function (dictClosed) {+ return grate(withGrate(g))(dictClosed);+ };+};+module.exports = {+ cloneGrate: cloneGrate, + collectOf: collectOf, + cotraversed: cotraversed, + grate: grate, + withGrate: withGrate, + zipFWithOf: zipFWithOf, + zipWithOf: zipWithOf+};++},{"../Control.Category":47,"../Data.Distributive":135,"../Data.Function":149,"../Data.Functor":155,"../Data.Lens.Internal.Grating":173,"../Data.Lens.Internal.Zipping":180,"../Data.Lens.Types":190,"../Data.Newtype":209,"../Data.Profunctor":225,"../Data.Profunctor.Closed":219,"../Data.Profunctor.Costar":221,"../Data.Profunctor.Star":223,"../Prelude":268}],170:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Category = require("../Control.Category");+var Control_Monad_State = require("../Control.Monad.State");+var Control_Monad_State_Class = require("../Control.Monad.State.Class");+var Control_Monad_State_Trans = require("../Control.Monad.State.Trans");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Functor_Compose = require("../Data.Functor.Compose");+var Data_Identity = require("../Data.Identity");+var Data_Lens_Internal_Indexed = require("../Data.Lens.Internal.Indexed");+var Data_Lens_Internal_Wander = require("../Data.Lens.Internal.Wander");+var Data_Lens_Types = require("../Data.Lens.Types");+var Data_Newtype = require("../Data.Newtype");+var Data_Profunctor = require("../Data.Profunctor");+var Data_Profunctor_Star = require("../Data.Profunctor.Star");+var Data_Semiring = require("../Data.Semiring");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var unIndex = function (dictProfunctor) {+ return function (l) {+ return function ($7) {+ return l(Data_Lens_Internal_Indexed.Indexed(Data_Profunctor.dimap(dictProfunctor)(Data_Tuple.snd)(Control_Category.id(Control_Category.categoryFn))($7)));+ };+ };+};+var iwander = function (itr) {+ return function (dictWander) {+ return function ($8) {+ return Data_Lens_Internal_Wander.wander(dictWander)(function (dictApplicative) {+ return function (f) {+ return function (s) {+ return itr(dictApplicative)(Data_Tuple.curry(f))(s);+ };+ };+ })(Data_Newtype.unwrap(Data_Lens_Internal_Indexed.newtypeIndexed)($8));+ };+ };+};+var positions = function (tr) {+ return function (dictWander) {+ return iwander(function (dictApplicative) {+ return function (f) {+ return function (s) {+ return Data_Function.flip(Control_Monad_State.evalState)(0)(Data_Newtype.unwrap(Data_Functor_Compose.newtypeCompose)(Data_Function.flip(Data_Newtype.unwrap(Data_Profunctor_Star.newtypeStar))(s)(tr(Data_Lens_Internal_Wander.wanderStar(Data_Functor_Compose.applicativeCompose(Control_Monad_State_Trans.applicativeStateT(Data_Identity.monadIdentity))(dictApplicative)))(function (a) {+ return Data_Functor_Compose.Compose(Control_Apply.applyFirst(Control_Monad_State_Trans.applyStateT(Data_Identity.monadIdentity))(Control_Apply.apply(Control_Monad_State_Trans.applyStateT(Data_Identity.monadIdentity))(Data_Functor.map(Control_Monad_State_Trans.functorStateT(Data_Identity.functorIdentity))(f)(Control_Monad_State_Class.get(Control_Monad_State_Trans.monadStateStateT(Data_Identity.monadIdentity))))(Control_Applicative.pure(Control_Monad_State_Trans.applicativeStateT(Data_Identity.monadIdentity))(a)))(Control_Monad_State_Class.modify(Control_Monad_State_Trans.monadStateStateT(Data_Identity.monadIdentity))(function (v) {+ return v + 1 | 0;+ })));+ }))));+ };+ };+ })(dictWander);+ };+};+var asIndex = function (dictProfunctor) {+ return function (l) {+ return function ($9) {+ return l(Data_Lens_Internal_Indexed.Indexed(Data_Profunctor.dimap(dictProfunctor)(Data_Tuple.fst)(Control_Category.id(Control_Category.categoryFn))($9)));+ };+ };+};+module.exports = {+ asIndex: asIndex, + iwander: iwander, + positions: positions, + unIndex: unIndex+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Category":47,"../Control.Monad.State":82,"../Control.Monad.State.Class":80,"../Control.Monad.State.Trans":81,"../Control.Semigroupoid":92,"../Data.Function":149,"../Data.Functor":155,"../Data.Functor.Compose":151,"../Data.Identity":161,"../Data.Lens.Internal.Indexed":174,"../Data.Lens.Internal.Wander":179,"../Data.Lens.Types":190,"../Data.Newtype":209,"../Data.Profunctor":225,"../Data.Profunctor.Star":223,"../Data.Semiring":231,"../Data.Tuple":245,"../Prelude":268}],171:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Functor = require("../Data.Functor");+var Data_Profunctor = require("../Data.Profunctor");+var Prelude = require("../Prelude");+var Exchange = (function () {+ function Exchange(value0, value1) {+ this.value0 = value0;+ this.value1 = value1;+ };+ Exchange.create = function (value0) {+ return function (value1) {+ return new Exchange(value0, value1);+ };+ };+ return Exchange;+})();+var profunctorExchange = new Data_Profunctor.Profunctor(function (f) {+ return function (g) {+ return function (v) {+ return new Exchange(function ($11) {+ return v.value0(f($11));+ }, function ($12) {+ return g(v.value1($12));+ });+ };+ };+});+var functorExchange = new Data_Functor.Functor(function (f) {+ return function (v) {+ return new Exchange(v.value0, function ($13) {+ return f(v.value1($13));+ });+ };+});+module.exports = {+ Exchange: Exchange, + functorExchange: functorExchange, + profunctorExchange: profunctorExchange+};++},{"../Control.Semigroupoid":92,"../Data.Functor":155,"../Data.Profunctor":225,"../Prelude":268}],172:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Const = require("../Data.Const");+var Data_Either = require("../Data.Either");+var Data_Functor = require("../Data.Functor");+var Data_Lens_Internal_Wander = require("../Data.Lens.Internal.Wander");+var Data_Monoid = require("../Data.Monoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Profunctor = require("../Data.Profunctor");+var Data_Profunctor_Choice = require("../Data.Profunctor.Choice");+var Data_Profunctor_Cochoice = require("../Data.Profunctor.Cochoice");+var Data_Profunctor_Strong = require("../Data.Profunctor.Strong");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var Forget = function (x) {+ return x;+};+var profunctorForget = new Data_Profunctor.Profunctor(function (f) {+ return function (v) {+ return function (v1) {+ return function ($25) {+ return v1(f($25));+ };+ };+ };+});+var strongForget = new Data_Profunctor_Strong.Strong(function () {+ return profunctorForget;+}, function (v) {+ return function ($26) {+ return v(Data_Tuple.fst($26));+ };+}, function (v) {+ return function ($27) {+ return v(Data_Tuple.snd($27));+ };+});+var newtypeForget = new Data_Newtype.Newtype(function (n) {+ return n;+}, Forget);+var cochoiceForget = new Data_Profunctor_Cochoice.Cochoice(function () {+ return profunctorForget;+}, function (v) {+ return function ($28) {+ return v(Data_Either.Left.create($28));+ };+}, function (v) {+ return function ($29) {+ return v(Data_Either.Right.create($29));+ };+});+var choiceForget = function (dictMonoid) {+ return new Data_Profunctor_Choice.Choice(function () {+ return profunctorForget;+ }, function (v) {+ return Data_Either.either(v)(Data_Monoid.mempty(Data_Monoid.monoidFn(dictMonoid)));+ }, function (v) {+ return Data_Either.either(Data_Monoid.mempty(Data_Monoid.monoidFn(dictMonoid)))(v);+ });+};+var wanderForget = function (dictMonoid) {+ return new Data_Lens_Internal_Wander.Wander(function () {+ return choiceForget(dictMonoid);+ }, function () {+ return strongForget;+ }, function (f) {+ return function (v) {+ return Data_Newtype.alaF(Data_Functor.functorFn)(Data_Functor.functorFn)(Data_Const.newtypeConst)(Data_Const.newtypeConst)(Data_Const.Const)(f(Data_Const.applicativeConst(dictMonoid)))(v);+ };+ });+};+module.exports = {+ Forget: Forget, + newtypeForget: newtypeForget, + profunctorForget: profunctorForget, + choiceForget: choiceForget, + strongForget: strongForget, + cochoiceForget: cochoiceForget, + wanderForget: wanderForget+};++},{"../Control.Semigroupoid":92,"../Data.Const":134,"../Data.Either":136,"../Data.Functor":155,"../Data.Lens.Internal.Wander":179,"../Data.Monoid":207,"../Data.Newtype":209,"../Data.Profunctor":225,"../Data.Profunctor.Choice":218,"../Data.Profunctor.Cochoice":220,"../Data.Profunctor.Strong":224,"../Data.Tuple":245,"../Prelude":268}],173:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Profunctor = require("../Data.Profunctor");+var Data_Profunctor_Closed = require("../Data.Profunctor.Closed");+var Prelude = require("../Prelude");+var Grating = function (x) {+ return x;+};+var profunctorGrating = new Data_Profunctor.Profunctor(function (f) {+ return function (g) {+ return function (v) {+ return function (d) {+ return g(v(function (k) {+ return d(function ($9) {+ return k(f($9));+ });+ }));+ };+ };+ };+});+var newtypeGrating = new Data_Newtype.Newtype(function (n) {+ return n;+}, Grating);+var closedGrating = new Data_Profunctor_Closed.Closed(function () {+ return profunctorGrating;+}, function (v) {+ return function (f) {+ return function (x) {+ return v(function (k) {+ return f(function (g) {+ return k(g(x));+ });+ });+ };+ };+});+module.exports = {+ Grating: Grating, + newtypeGrating: newtypeGrating, + profunctorGrating: profunctorGrating, + closedGrating: closedGrating+};++},{"../Control.Semigroupoid":92,"../Data.Newtype":209,"../Data.Profunctor":225,"../Data.Profunctor.Closed":219,"../Prelude":268}],174:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Either = require("../Data.Either");+var Data_Function = require("../Data.Function");+var Data_Lens_Internal_Wander = require("../Data.Lens.Internal.Wander");+var Data_Newtype = require("../Data.Newtype");+var Data_Profunctor = require("../Data.Profunctor");+var Data_Profunctor_Choice = require("../Data.Profunctor.Choice");+var Data_Profunctor_Strong = require("../Data.Profunctor.Strong");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var Indexed = function (x) {+ return x;+};+var profunctorIndexed = function (dictProfunctor) {+ return new Data_Profunctor.Profunctor(function (f) {+ return function (g) {+ return function (v) {+ return Data_Profunctor.dimap(dictProfunctor)(Data_Profunctor_Strong.second(Data_Profunctor_Strong.strongFn)(f))(g)(v);+ };+ };+ });+};+var strongIndexed = function (dictStrong) {+ return new Data_Profunctor_Strong.Strong(function () {+ return profunctorIndexed(dictStrong.Profunctor0());+ }, function (v) {+ return Indexed(Data_Profunctor.lmap(dictStrong.Profunctor0())(function (v1) {+ return new Data_Tuple.Tuple(new Data_Tuple.Tuple(v1.value0, v1.value1.value0), v1.value1.value1);+ })(Data_Profunctor_Strong.first(dictStrong)(v)));+ }, function (v) {+ return Indexed(Data_Profunctor.lmap(dictStrong.Profunctor0())(function (v1) {+ return new Data_Tuple.Tuple(v1.value1.value0, new Data_Tuple.Tuple(v1.value0, v1.value1.value1));+ })(Data_Profunctor_Strong.second(dictStrong)(v)));+ });+};+var newtypeIndexed = new Data_Newtype.Newtype(function (n) {+ return n;+}, Indexed);+var choiceIndexed = function (dictChoice) {+ return new Data_Profunctor_Choice.Choice(function () {+ return profunctorIndexed(dictChoice.Profunctor0());+ }, function (v) {+ return Indexed(Data_Profunctor.lmap(dictChoice.Profunctor0())(function (v1) {+ return Data_Either.either(function ($47) {+ return Data_Either.Left.create(Data_Tuple.Tuple.create(v1.value0)($47));+ })(Data_Either.Right.create)(v1.value1);+ })(Data_Profunctor_Choice.left(dictChoice)(v)));+ }, function (v) {+ return Indexed(Data_Profunctor.lmap(dictChoice.Profunctor0())(function (v1) {+ return Data_Either.either(Data_Either.Left.create)(function ($48) {+ return Data_Either.Right.create(Data_Tuple.Tuple.create(v1.value0)($48));+ })(v1.value1);+ })(Data_Profunctor_Choice.right(dictChoice)(v)));+ });+};+var wanderIndexed = function (dictWander) {+ return new Data_Lens_Internal_Wander.Wander(function () {+ return choiceIndexed(dictWander.Choice1());+ }, function () {+ return strongIndexed(dictWander.Strong0());+ }, function (trav) {+ return function (v) {+ return Indexed(Data_Lens_Internal_Wander.wander(dictWander)(function (dictApplicative) {+ return function (ia2fb) {+ return function (v1) {+ return trav(dictApplicative)(function ($49) {+ return ia2fb(Data_Tuple.Tuple.create(v1.value0)($49));+ })(v1.value1);+ };+ };+ })(v));+ };+ });+};+module.exports = {+ Indexed: Indexed, + newtypeIndexed: newtypeIndexed, + profunctorIndexed: profunctorIndexed, + strongIndexed: strongIndexed, + choiceIndexed: choiceIndexed, + wanderIndexed: wanderIndexed+};++},{"../Control.Semigroupoid":92,"../Data.Either":136,"../Data.Function":149,"../Data.Lens.Internal.Wander":179,"../Data.Newtype":209,"../Data.Profunctor":225,"../Data.Profunctor.Choice":218,"../Data.Profunctor.Strong":224,"../Data.Tuple":245,"../Prelude":268}],175:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Bifunctor = require("../Data.Bifunctor");+var Data_Either = require("../Data.Either");+var Data_Functor = require("../Data.Functor");+var Data_Profunctor = require("../Data.Profunctor");+var Data_Profunctor_Choice = require("../Data.Profunctor.Choice");+var Prelude = require("../Prelude");+var Market = (function () {+ function Market(value0, value1) {+ this.value0 = value0;+ this.value1 = value1;+ };+ Market.create = function (value0) {+ return function (value1) {+ return new Market(value0, value1);+ };+ };+ return Market;+})();+var profunctorMarket = new Data_Profunctor.Profunctor(function (f) {+ return function (g) {+ return function (v) {+ return new Market(function ($19) {+ return g(v.value0($19));+ }, function ($20) {+ return Data_Bifunctor.lmap(Data_Either.bifunctorEither)(g)(v.value1(f($20)));+ });+ };+ };+});+var functorMarket = new Data_Functor.Functor(function (f) {+ return function (v) {+ return new Market(function ($21) {+ return f(v.value0($21));+ }, function ($22) {+ return Data_Bifunctor.lmap(Data_Either.bifunctorEither)(f)(v.value1($22));+ });+ };+});+var choiceMarket = new Data_Profunctor_Choice.Choice(function () {+ return profunctorMarket;+}, function (v) {+ return new Market(function ($23) {+ return Data_Either.Left.create(v.value0($23));+ }, Data_Either.either(function ($24) {+ return Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Either.Left.create)(v.value1($24));+ })(function ($25) {+ return Data_Either.Left.create(Data_Either.Right.create($25));+ }));+}, function (v) {+ return new Market(function ($26) {+ return Data_Either.Right.create(v.value0($26));+ }, Data_Either.either(function ($27) {+ return Data_Either.Left.create(Data_Either.Left.create($27));+ })(function ($28) {+ return Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Either.Right.create)(v.value1($28));+ }));+});+module.exports = {+ Market: Market, + functorMarket: functorMarket, + profunctorMarket: profunctorMarket, + choiceMarket: choiceMarket+};++},{"../Control.Semigroupoid":92,"../Data.Bifunctor":127,"../Data.Either":136,"../Data.Functor":155,"../Data.Profunctor":225,"../Data.Profunctor.Choice":218,"../Prelude":268}],176:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Profunctor = require("../Data.Profunctor");+var Data_Profunctor_Choice = require("../Data.Profunctor.Choice");+var Data_Profunctor_Cochoice = require("../Data.Profunctor.Cochoice");+var Data_Profunctor_Costrong = require("../Data.Profunctor.Costrong");+var Data_Profunctor_Strong = require("../Data.Profunctor.Strong");+var Prelude = require("../Prelude");+var Re = function (x) {+ return x;+};+var profunctorRe = function (dictProfunctor) {+ return new Data_Profunctor.Profunctor(function (f) {+ return function (g) {+ return function (v) {+ return function ($28) {+ return v(Data_Profunctor.dimap(dictProfunctor)(g)(f)($28));+ };+ };+ };+ });+};+var strongRe = function (dictStrong) {+ return new Data_Profunctor_Costrong.Costrong(function () {+ return profunctorRe(dictStrong.Profunctor0());+ }, function (v) {+ return function ($29) {+ return v(Data_Profunctor_Strong.first(dictStrong)($29));+ };+ }, function (v) {+ return function ($30) {+ return v(Data_Profunctor_Strong.second(dictStrong)($30));+ };+ });+};+var newtypeRe = new Data_Newtype.Newtype(function (n) {+ return n;+}, Re);+var costrongRe = function (dictCostrong) {+ return new Data_Profunctor_Strong.Strong(function () {+ return profunctorRe(dictCostrong.Profunctor0());+ }, function (v) {+ return function ($31) {+ return v(Data_Profunctor_Costrong.unfirst(dictCostrong)($31));+ };+ }, function (v) {+ return function ($32) {+ return v(Data_Profunctor_Costrong.unsecond(dictCostrong)($32));+ };+ });+};+var cochoiceRe = function (dictCochoice) {+ return new Data_Profunctor_Choice.Choice(function () {+ return profunctorRe(dictCochoice.Profunctor0());+ }, function (v) {+ return function ($33) {+ return v(Data_Profunctor_Cochoice.unleft(dictCochoice)($33));+ };+ }, function (v) {+ return function ($34) {+ return v(Data_Profunctor_Cochoice.unright(dictCochoice)($34));+ };+ });+};+var choiceRe = function (dictChoice) {+ return new Data_Profunctor_Cochoice.Cochoice(function () {+ return profunctorRe(dictChoice.Profunctor0());+ }, function (v) {+ return function ($35) {+ return v(Data_Profunctor_Choice.left(dictChoice)($35));+ };+ }, function (v) {+ return function ($36) {+ return v(Data_Profunctor_Choice.right(dictChoice)($36));+ };+ });+};+module.exports = {+ Re: Re, + newtypeRe: newtypeRe, + profunctorRe: profunctorRe, + choiceRe: choiceRe, + cochoiceRe: cochoiceRe, + strongRe: strongRe, + costrongRe: costrongRe+};++},{"../Control.Semigroupoid":92,"../Data.Newtype":209,"../Data.Profunctor":225,"../Data.Profunctor.Choice":218,"../Data.Profunctor.Cochoice":220,"../Data.Profunctor.Costrong":222,"../Data.Profunctor.Strong":224,"../Prelude":268}],177:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Profunctor = require("../Data.Profunctor");+var Data_Profunctor_Strong = require("../Data.Profunctor.Strong");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var Shop = (function () {+ function Shop(value0, value1) {+ this.value0 = value0;+ this.value1 = value1;+ };+ Shop.create = function (value0) {+ return function (value1) {+ return new Shop(value0, value1);+ };+ };+ return Shop;+})();+var profunctorShop = new Data_Profunctor.Profunctor(function (f) {+ return function (g) {+ return function (v) {+ return new Shop(function ($30) {+ return v.value0(f($30));+ }, function (s) {+ return function ($31) {+ return g(v.value1(f(s))($31));+ };+ });+ };+ };+});+var strongShop = new Data_Profunctor_Strong.Strong(function () {+ return profunctorShop;+}, function (v) {+ return new Shop(function (v1) {+ return v.value0(v1.value0);+ }, function (v1) {+ return function (b) {+ return new Data_Tuple.Tuple(v.value1(v1.value0)(b), v1.value1);+ };+ });+}, function (v) {+ return new Shop(function (v1) {+ return v.value0(v1.value1);+ }, function (v1) {+ return function (b) {+ return new Data_Tuple.Tuple(v1.value0, v.value1(v1.value1)(b));+ };+ });+});+module.exports = {+ Shop: Shop, + profunctorShop: profunctorShop, + strongShop: strongShop+};++},{"../Control.Semigroupoid":92,"../Data.Profunctor":225,"../Data.Profunctor.Strong":224,"../Data.Tuple":245,"../Prelude":268}],178:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Either = require("../Data.Either");+var Data_Newtype = require("../Data.Newtype");+var Data_Profunctor = require("../Data.Profunctor");+var Data_Profunctor_Choice = require("../Data.Profunctor.Choice");+var Data_Profunctor_Costrong = require("../Data.Profunctor.Costrong");+var Data_Tuple = require("../Data.Tuple");+var Tagged = function (x) {+ return x;+};+var taggedProfunctor = new Data_Profunctor.Profunctor(function (v) {+ return function (g) {+ return function (v1) {+ return g(v1);+ };+ };+});+var taggedCostrong = new Data_Profunctor_Costrong.Costrong(function () {+ return taggedProfunctor;+}, function (v) {+ return v.value0;+}, function (v) {+ return v.value1;+});+var taggedChoice = new Data_Profunctor_Choice.Choice(function () {+ return taggedProfunctor;+}, function (v) {+ return new Data_Either.Left(v);+}, function (v) {+ return new Data_Either.Right(v);+});+var newtypeTagged = new Data_Newtype.Newtype(function (n) {+ return n;+}, Tagged);+module.exports = {+ Tagged: Tagged, + newtypeTagged: newtypeTagged, + taggedProfunctor: taggedProfunctor, + taggedChoice: taggedChoice, + taggedCostrong: taggedCostrong+};++},{"../Data.Either":136,"../Data.Newtype":209,"../Data.Profunctor":225,"../Data.Profunctor.Choice":218,"../Data.Profunctor.Costrong":222,"../Data.Tuple":245}],179:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Functor = require("../Data.Functor");+var Data_Identity = require("../Data.Identity");+var Data_Newtype = require("../Data.Newtype");+var Data_Profunctor_Choice = require("../Data.Profunctor.Choice");+var Data_Profunctor_Star = require("../Data.Profunctor.Star");+var Data_Profunctor_Strong = require("../Data.Profunctor.Strong");+var Prelude = require("../Prelude");+var Wander = function (Choice1, Strong0, wander) {+ this.Choice1 = Choice1;+ this.Strong0 = Strong0;+ this.wander = wander;+};+var wanderStar = function (dictApplicative) {+ return new Wander(function () {+ return Data_Profunctor_Star.choiceStar(dictApplicative);+ }, function () {+ return Data_Profunctor_Star.strongStar((dictApplicative.Apply0()).Functor0());+ }, function (t) {+ return function (v) {+ return t(dictApplicative)(v);+ };+ });+};+var wanderFunction = new Wander(function () {+ return Data_Profunctor_Choice.choiceFn;+}, function () {+ return Data_Profunctor_Strong.strongFn;+}, function (t) {+ return Data_Newtype.alaF(Data_Functor.functorFn)(Data_Functor.functorFn)(Data_Identity.newtypeIdentity)(Data_Identity.newtypeIdentity)(Data_Identity.Identity)(t(Data_Identity.applicativeIdentity));+});+var wander = function (dict) {+ return dict.wander;+};+module.exports = {+ Wander: Wander, + wander: wander, + wanderFunction: wanderFunction, + wanderStar: wanderStar+};++},{"../Data.Functor":155,"../Data.Identity":161,"../Data.Newtype":209,"../Data.Profunctor.Choice":218,"../Data.Profunctor.Star":223,"../Data.Profunctor.Strong":224,"../Prelude":268}],180:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Newtype = require("../Data.Newtype");+var Data_Profunctor = require("../Data.Profunctor");+var Data_Profunctor_Closed = require("../Data.Profunctor.Closed");+var Zipping = function (x) {+ return x;+};+var profunctorZipping = new Data_Profunctor.Profunctor(function (f) {+ return function (g) {+ return function (v) {+ return function (a1) {+ return function (a2) {+ return g(v(f(a1))(f(a2)));+ };+ };+ };+ };+});+var newtypeZipping = new Data_Newtype.Newtype(function (n) {+ return n;+}, Zipping);+var closedZipping = new Data_Profunctor_Closed.Closed(function () {+ return profunctorZipping;+}, function (v) {+ return function (f1) {+ return function (f2) {+ return function (x) {+ return v(f1(x))(f2(x));+ };+ };+ };+});+module.exports = {+ Zipping: Zipping, + newtypeZipping: newtypeZipping, + profunctorZipping: profunctorZipping, + closedZipping: closedZipping+};++},{"../Data.Newtype":209,"../Data.Profunctor":225,"../Data.Profunctor.Closed":219}],181:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Boolean = require("../Data.Boolean");+var Data_Eq = require("../Data.Eq");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Lens_Internal_Exchange = require("../Data.Lens.Internal.Exchange");+var Data_Lens_Internal_Re = require("../Data.Lens.Internal.Re");+var Data_Lens_Types = require("../Data.Lens.Types");+var Data_Maybe = require("../Data.Maybe");+var Data_Newtype = require("../Data.Newtype");+var Data_Profunctor = require("../Data.Profunctor");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var withIso = function (l) {+ return function (f) {+ var v = l(new Data_Lens_Internal_Exchange.Exchange(Control_Category.id(Control_Category.categoryFn), Control_Category.id(Control_Category.categoryFn)));+ return f(v.value0)(v.value1);+ };+};+var under = function (l) {+ return withIso(l)(function (sa) {+ return function (bt) {+ return function (ts) {+ return function ($19) {+ return sa(ts(bt($19)));+ };+ };+ };+ });+};+var re = function (t) {+ return Data_Newtype.unwrap(Data_Lens_Internal_Re.newtypeRe)(t(Control_Category.id(Control_Category.categoryFn)));+};+var iso = function (f) {+ return function (g) {+ return function (dictProfunctor) {+ return function (pab) {+ return Data_Profunctor.dimap(dictProfunctor)(f)(g)(pab);+ };+ };+ };+};+var mapping = function (dictFunctor) {+ return function (dictFunctor1) {+ return function (l) {+ return function (dictProfunctor) {+ return withIso(l)(function (sa) {+ return function (bt) {+ return iso(Data_Functor.map(dictFunctor)(sa))(Data_Functor.map(dictFunctor1)(bt))(dictProfunctor);+ };+ });+ };+ };+ };+};+var non = function (dictEq) {+ return function (def) {+ return function (dictProfunctor) {+ var g = function (a) {+ if (Data_Eq.eq(dictEq)(a)(def)) {+ return Data_Maybe.Nothing.value;+ };+ if (Data_Boolean.otherwise) {+ return new Data_Maybe.Just(a);+ };+ throw new Error("Failed pattern match at Data.Lens.Iso line 44, column 9 - line 45, column 33: " + [ a.constructor.name ]);+ };+ return iso(Data_Maybe.fromMaybe(def))(g)(dictProfunctor);+ };+ };+};+var uncurried = function (dictProfunctor) {+ return iso(Data_Tuple.uncurry)(Data_Tuple.curry)(dictProfunctor);+};+var flipped = function (dictProfunctor) {+ return iso(Data_Function.flip)(Data_Function.flip)(dictProfunctor);+};+var dimapping = function (dictProfunctor) {+ return function (dictProfunctor1) {+ return function (f) {+ return function (g) {+ return function (dictProfunctor2) {+ return withIso(f)(function (sa) {+ return function (bt) {+ return withIso(g)(function (ssaa) {+ return function (bbtt) {+ return iso(Data_Profunctor.dimap(dictProfunctor)(sa)(ssaa))(Data_Profunctor.dimap(dictProfunctor1)(bt)(bbtt))(dictProfunctor2);+ };+ });+ };+ });+ };+ };+ };+ };+};+var curried = function (dictProfunctor) {+ return iso(Data_Tuple.curry)(Data_Tuple.uncurry)(dictProfunctor);+};+var cloneIso = function (l) {+ return function (dictProfunctor) {+ return withIso(l)(function (x) {+ return function (y) {+ return function (p) {+ return iso(x)(y)(dictProfunctor)(p);+ };+ };+ });+ };+};+var auf = function (dictProfunctor) {+ return function (l) {+ return withIso(l)(function (sa) {+ return function (bt) {+ return function (f) {+ return function (g) {+ return function (e) {+ return bt(f(Data_Profunctor.rmap(dictProfunctor)(sa)(g))(e));+ };+ };+ };+ };+ });+ };+};+var au = function (l) {+ return withIso(l)(function (sa) {+ return function (bt) {+ return function (f) {+ return function (e) {+ return sa(f(bt)(e));+ };+ };+ };+ });+};+module.exports = {+ au: au, + auf: auf, + cloneIso: cloneIso, + curried: curried, + dimapping: dimapping, + flipped: flipped, + iso: iso, + mapping: mapping, + non: non, + re: re, + uncurried: uncurried, + under: under, + withIso: withIso+};++},{"../Control.Category":47,"../Control.Semigroupoid":92,"../Data.Boolean":129,"../Data.Eq":138,"../Data.Function":149,"../Data.Functor":155,"../Data.Lens.Internal.Exchange":171,"../Data.Lens.Internal.Re":176,"../Data.Lens.Types":190,"../Data.Maybe":198,"../Data.Newtype":209,"../Data.Profunctor":225,"../Data.Tuple":245,"../Prelude":268}],182:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Lens_Lens = require("../Data.Lens.Lens");+var Data_Profunctor_Strong = require("../Data.Profunctor.Strong");+var Data_Tuple = require("../Data.Tuple");+var _2 = function (dictStrong) {+ return Data_Profunctor_Strong.second(dictStrong);+};+var _1 = function (dictStrong) {+ return Data_Profunctor_Strong.first(dictStrong);+};+module.exports = {+ _1: _1, + _2: _2+};++},{"../Data.Lens.Lens":184,"../Data.Profunctor.Strong":224,"../Data.Tuple":245}],183:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Function = require("../Data.Function");+var Data_Lens_Lens = require("../Data.Lens.Lens");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var united = function (dictStrong) {+ return Data_Lens_Lens.lens(Data_Function["const"](Data_Unit.unit))(Data_Function["const"])(dictStrong);+};+module.exports = {+ united: united+};++},{"../Data.Function":149,"../Data.Lens.Lens":184,"../Data.Unit":249,"../Prelude":268}],184:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var Data_Lens_Internal_Indexed = require("../Data.Lens.Internal.Indexed");+var Data_Lens_Internal_Shop = require("../Data.Lens.Internal.Shop");+var Data_Lens_Types = require("../Data.Lens.Types");+var Data_Newtype = require("../Data.Newtype");+var Data_Profunctor = require("../Data.Profunctor");+var Data_Profunctor_Strong = require("../Data.Profunctor.Strong");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var withLens = function (l) {+ return function (f) {+ var v = l(new Data_Lens_Internal_Shop.Shop(Control_Category.id(Control_Category.categoryFn), function (v1) {+ return function (b) {+ return b;+ };+ }));+ return f(v.value0)(v.value1);+ };+};+var withIndexedLens = function (l) {+ return function (f) {+ var v = l(new Data_Lens_Internal_Shop.Shop(Control_Category.id(Control_Category.categoryFn), function (v1) {+ return function (b) {+ return b;+ };+ }));+ return f(v.value0)(v.value1);+ };+};+var lens$prime = function (to) {+ return function (dictStrong) {+ return function (pab) {+ return Data_Profunctor.dimap(dictStrong.Profunctor0())(to)(function (v) {+ return v.value1(v.value0);+ })(Data_Profunctor_Strong.first(dictStrong)(pab));+ };+ };+};+var lens = function (get) {+ return function (set) {+ return function (dictStrong) {+ return lens$prime(function (s) {+ return new Data_Tuple.Tuple(get(s), function (b) {+ return set(s)(b);+ });+ })(dictStrong);+ };+ };+};+var ilens$prime = function (to) {+ return function (dictStrong) {+ return function (pab) {+ return Data_Profunctor.dimap(dictStrong.Profunctor0())(to)(function (v) {+ return v.value1(v.value0);+ })(Data_Profunctor_Strong.first(dictStrong)(Data_Newtype.un(Data_Lens_Internal_Indexed.newtypeIndexed)(Data_Lens_Internal_Indexed.Indexed)(pab)));+ };+ };+};+var ilens = function (get) {+ return function (set) {+ return function (dictStrong) {+ return ilens$prime(function (s) {+ return new Data_Tuple.Tuple(get(s), function (b) {+ return set(s)(b);+ });+ })(dictStrong);+ };+ };+};+var cloneLens = function (l) {+ return function (dictStrong) {+ return withLens(l)(function (x) {+ return function (y) {+ return function (p) {+ return lens(x)(y)(dictStrong)(p);+ };+ };+ });+ };+};+var cloneIndexedLens = function (l) {+ return function (dictStrong) {+ return withIndexedLens(l)(function (x) {+ return function (y) {+ return function (p) {+ return ilens(x)(y)(dictStrong)(p);+ };+ };+ });+ };+};+module.exports = {+ cloneIndexedLens: cloneIndexedLens, + cloneLens: cloneLens, + ilens: ilens, + "ilens'": ilens$prime, + lens: lens, + "lens'": lens$prime, + withIndexedLens: withIndexedLens, + withLens: withLens+};++},{"../Control.Category":47,"../Data.Lens.Internal.Indexed":174,"../Data.Lens.Internal.Shop":177,"../Data.Lens.Types":190,"../Data.Newtype":209,"../Data.Profunctor":225,"../Data.Profunctor.Strong":224,"../Data.Tuple":245,"../Prelude":268}],185:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Either = require("../Data.Either");+var Data_Lens_Prism = require("../Data.Lens.Prism");+var Data_Profunctor_Choice = require("../Data.Profunctor.Choice");+var _Right = function (dictChoice) {+ return Data_Profunctor_Choice.right(dictChoice);+};+var _Left = function (dictChoice) {+ return Data_Profunctor_Choice.left(dictChoice);+};+module.exports = {+ _Left: _Left, + _Right: _Right+};++},{"../Data.Either":136,"../Data.Lens.Prism":187,"../Data.Profunctor.Choice":218}],186:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Either = require("../Data.Either");+var Data_Function = require("../Data.Function");+var Data_Lens_Prism = require("../Data.Lens.Prism");+var Data_Maybe = require("../Data.Maybe");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var _Nothing = function (dictChoice) {+ return Data_Lens_Prism.prism(Data_Function["const"](Data_Maybe.Nothing.value))(Data_Maybe.maybe(new Data_Either.Right(Data_Unit.unit))(Data_Function["const"](new Data_Either.Left(Data_Maybe.Nothing.value))))(dictChoice);+};+var _Just = function (dictChoice) {+ return Data_Lens_Prism.prism(Data_Maybe.Just.create)(Data_Maybe.maybe(new Data_Either.Left(Data_Maybe.Nothing.value))(Data_Either.Right.create))(dictChoice);+};+module.exports = {+ _Just: _Just, + _Nothing: _Nothing+};++},{"../Data.Either":136,"../Data.Function":149,"../Data.Lens.Prism":187,"../Data.Maybe":198,"../Data.Unit":249,"../Prelude":268}],187:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var Control_MonadPlus = require("../Control.MonadPlus");+var Control_MonadZero = require("../Control.MonadZero");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Either = require("../Data.Either");+var Data_Eq = require("../Data.Eq");+var Data_Function = require("../Data.Function");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Lens_Internal_Market = require("../Data.Lens.Internal.Market");+var Data_Lens_Internal_Tagged = require("../Data.Lens.Internal.Tagged");+var Data_Lens_Types = require("../Data.Lens.Types");+var Data_Maybe = require("../Data.Maybe");+var Data_Newtype = require("../Data.Newtype");+var Data_Profunctor = require("../Data.Profunctor");+var Data_Profunctor_Choice = require("../Data.Profunctor.Choice");+var Prelude = require("../Prelude");+var withPrism = function (l) {+ return function (f) {+ var v = l(new Data_Lens_Internal_Market.Market(Control_Category.id(Control_Category.categoryFn), Data_Either.Right.create));+ return f(v.value0)(v.value1);+ };+};+var review = Data_Newtype.under(Data_Lens_Internal_Tagged.newtypeTagged)(Data_Lens_Internal_Tagged.newtypeTagged)(Data_Lens_Internal_Tagged.Tagged);+var prism = function (to) {+ return function (fro) {+ return function (dictChoice) {+ return function (pab) {+ return Data_Profunctor.dimap(dictChoice.Profunctor0())(fro)(Data_Either.either(Control_Category.id(Control_Category.categoryFn))(Control_Category.id(Control_Category.categoryFn)))(Data_Profunctor_Choice.right(dictChoice)(Data_Profunctor.rmap(dictChoice.Profunctor0())(to)(pab)));+ };+ };+ };+};+var prism$prime = function (to) {+ return function (fro) {+ return function (dictChoice) {+ return prism(to)(function (s) {+ return Data_Maybe.maybe(new Data_Either.Left(s))(Data_Either.Right.create)(fro(s));+ })(dictChoice);+ };+ };+};+var nearly = function (x) {+ return function (f) {+ return function (dictChoice) {+ return prism$prime(Data_Function["const"](x))(function ($14) {+ return Control_MonadZero.guard(Data_Maybe.monadZeroMaybe)(f($14));+ })(dictChoice);+ };+ };+};+var only = function (dictEq) {+ return function (x) {+ return function (dictChoice) {+ return nearly(x)(function (v) {+ return Data_Eq.eq(dictEq)(v)(x);+ })(dictChoice);+ };+ };+};+var matching = function (l) {+ return withPrism(l)(function (v) {+ return function (f) {+ return f;+ };+ });+};+var is = function (dictHeytingAlgebra) {+ return function (l) {+ return function ($15) {+ return Data_Either.either(Data_Function["const"](Data_HeytingAlgebra.ff(dictHeytingAlgebra)))(Data_Function["const"](Data_HeytingAlgebra.tt(dictHeytingAlgebra)))(matching(l)($15));+ };+ };+};+var isn$primet = function (dictHeytingAlgebra) {+ return function (l) {+ return function ($16) {+ return Data_HeytingAlgebra.not(dictHeytingAlgebra)(is(dictHeytingAlgebra)(l)($16));+ };+ };+};+var clonePrism = function (l) {+ return function (dictChoice) {+ return withPrism(l)(function (x) {+ return function (y) {+ return function (p) {+ return prism(x)(y)(dictChoice)(p);+ };+ };+ });+ };+};+module.exports = {+ clonePrism: clonePrism, + is: is, + "isn't": isn$primet, + matching: matching, + nearly: nearly, + only: only, + prism: prism, + "prism'": prism$prime, + review: review, + withPrism: withPrism+};++},{"../Control.Category":47,"../Control.MonadPlus":87,"../Control.MonadZero":88,"../Control.Semigroupoid":92,"../Data.Either":136,"../Data.Eq":138,"../Data.Function":149,"../Data.HeytingAlgebra":160,"../Data.Lens.Internal.Market":175,"../Data.Lens.Internal.Tagged":178,"../Data.Lens.Types":190,"../Data.Maybe":198,"../Data.Newtype":209,"../Data.Profunctor":225,"../Data.Profunctor.Choice":218,"../Prelude":268}],188:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Monad_State_Class = require("../Control.Monad.State.Class");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_EuclideanRing = require("../Data.EuclideanRing");+var Data_Function = require("../Data.Function");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Lens_Internal_Indexed = require("../Data.Lens.Internal.Indexed");+var Data_Lens_Types = require("../Data.Lens.Types");+var Data_Maybe = require("../Data.Maybe");+var Data_Ring = require("../Data.Ring");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var over = function (l) {+ return l;+};+var set = function (l) {+ return function (b) {+ return over(l)(Data_Function["const"](b));+ };+};+var setJust = function (p) {+ return function ($24) {+ return set(p)(Data_Maybe.Just.create($24));+ };+};+var subOver = function (dictRing) {+ return function (p) {+ return function ($25) {+ return over(p)(Data_Function.flip(Data_Ring.sub(dictRing))($25));+ };+ };+};+var mulOver = function (dictSemiring) {+ return function (p) {+ return function ($26) {+ return over(p)(Data_Function.flip(Data_Semiring.mul(dictSemiring))($26));+ };+ };+};+var modifying = function (dictMonadState) {+ return function (p) {+ return function (f) {+ return Control_Monad_State_Class.modify(dictMonadState)(over(p)(f));+ };+ };+};+var mulModifying = function (dictMonadState) {+ return function (dictSemiring) {+ return function (p) {+ return function ($27) {+ return modifying(dictMonadState)(p)(Data_Function.flip(Data_Semiring.mul(dictSemiring))($27));+ };+ };+ };+};+var subModifying = function (dictMonadState) {+ return function (dictRing) {+ return function (p) {+ return function ($28) {+ return modifying(dictMonadState)(p)(Data_Function.flip(Data_Ring.sub(dictRing))($28));+ };+ };+ };+};+var iover = function (l) {+ return function (f) {+ return l(Data_Lens_Internal_Indexed.Indexed(Data_Tuple.uncurry(f)));+ };+};+var divOver = function (dictEuclideanRing) {+ return function (p) {+ return function ($29) {+ return over(p)(Data_Function.flip(Data_EuclideanRing.div(dictEuclideanRing))($29));+ };+ };+};+var divModifying = function (dictMonadState) {+ return function (dictEuclideanRing) {+ return function (p) {+ return function ($30) {+ return modifying(dictMonadState)(p)(Data_Function.flip(Data_EuclideanRing.div(dictEuclideanRing))($30));+ };+ };+ };+};+var disjOver = function (dictHeytingAlgebra) {+ return function (p) {+ return function ($31) {+ return over(p)(Data_Function.flip(Data_HeytingAlgebra.disj(dictHeytingAlgebra))($31));+ };+ };+};+var disjModifying = function (dictMonadState) {+ return function (dictHeytingAlgebra) {+ return function (p) {+ return function ($32) {+ return modifying(dictMonadState)(p)(Data_Function.flip(Data_HeytingAlgebra.disj(dictHeytingAlgebra))($32));+ };+ };+ };+};+var conjOver = function (dictHeytingAlgebra) {+ return function (p) {+ return function ($33) {+ return over(p)(Data_Function.flip(Data_HeytingAlgebra.conj(dictHeytingAlgebra))($33));+ };+ };+};+var conjModifying = function (dictMonadState) {+ return function (dictHeytingAlgebra) {+ return function (p) {+ return function ($34) {+ return modifying(dictMonadState)(p)(Data_Function.flip(Data_HeytingAlgebra.conj(dictHeytingAlgebra))($34));+ };+ };+ };+};+var assign = function (dictMonadState) {+ return function (p) {+ return function (b) {+ return Control_Monad_State_Class.modify(dictMonadState)(set(p)(b));+ };+ };+};+var assignJust = function (dictMonadState) {+ return function (p) {+ return function ($35) {+ return assign(dictMonadState)(p)(Data_Maybe.Just.create($35));+ };+ };+};+var appendOver = function (dictSemigroup) {+ return function (p) {+ return function ($36) {+ return over(p)(Data_Function.flip(Data_Semigroup.append(dictSemigroup))($36));+ };+ };+};+var appendModifying = function (dictMonadState) {+ return function (dictSemigroup) {+ return function (p) {+ return function ($37) {+ return modifying(dictMonadState)(p)(Data_Function.flip(Data_Semigroup.append(dictSemigroup))($37));+ };+ };+ };+};+var addOver = function (dictSemiring) {+ return function (p) {+ return function ($38) {+ return over(p)(Data_Semiring.add(dictSemiring)($38));+ };+ };+};+var addModifying = function (dictMonadState) {+ return function (dictSemiring) {+ return function (p) {+ return function ($39) {+ return modifying(dictMonadState)(p)(Data_Semiring.add(dictSemiring)($39));+ };+ };+ };+};+module.exports = {+ addModifying: addModifying, + addOver: addOver, + appendModifying: appendModifying, + appendOver: appendOver, + assign: assign, + assignJust: assignJust, + conjModifying: conjModifying, + conjOver: conjOver, + disjModifying: disjModifying, + disjOver: disjOver, + divModifying: divModifying, + divOver: divOver, + iover: iover, + modifying: modifying, + mulModifying: mulModifying, + mulOver: mulOver, + over: over, + set: set, + setJust: setJust, + subModifying: subModifying, + subOver: subOver+};++},{"../Control.Monad.State.Class":80,"../Control.Semigroupoid":92,"../Data.EuclideanRing":140,"../Data.Function":149,"../Data.HeytingAlgebra":160,"../Data.Lens.Internal.Indexed":174,"../Data.Lens.Types":190,"../Data.Maybe":198,"../Data.Ring":227,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Tuple":245,"../Prelude":268}],189:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alternative = require("../Control.Alternative");+var Control_Applicative = require("../Control.Applicative");+var Control_Category = require("../Control.Category");+var Control_Plus = require("../Control.Plus");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Eq = require("../Data.Eq");+var Data_Function = require("../Data.Function");+var Data_Lens_Indexed = require("../Data.Lens.Indexed");+var Data_Lens_Internal_Indexed = require("../Data.Lens.Internal.Indexed");+var Data_Lens_Internal_Wander = require("../Data.Lens.Internal.Wander");+var Data_Lens_Types = require("../Data.Lens.Types");+var Data_Monoid_Disj = require("../Data.Monoid.Disj");+var Data_Newtype = require("../Data.Newtype");+var Data_Profunctor_Star = require("../Data.Profunctor.Star");+var Data_Traversable = require("../Data.Traversable");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var traversed = function (dictTraversable) {+ return function (dictWander) {+ return Data_Lens_Internal_Wander.wander(dictWander)(function (dictApplicative) {+ return Data_Traversable.traverse(dictTraversable)(dictApplicative);+ });+ };+};+var traverseOf = function (dictApplicative) {+ return Data_Newtype.under(Data_Profunctor_Star.newtypeStar)(Data_Profunctor_Star.newtypeStar)(Data_Profunctor_Star.Star);+};+var sequenceOf = function (dictApplicative) {+ return function (t) {+ return traverseOf(dictApplicative)(t)(Control_Category.id(Control_Category.categoryFn));+ };+};+var itraverseOf = function (dictApplicative) {+ return function (t) {+ return function ($24) {+ return Data_Newtype.under(Data_Profunctor_Star.newtypeStar)(Data_Profunctor_Star.newtypeStar)(Data_Profunctor_Star.Star)(function ($25) {+ return t(Data_Lens_Internal_Indexed.Indexed($25));+ })(Data_Tuple.uncurry($24));+ };+ };+};+var failover = function (dictAlternative) {+ return function (t) {+ return function (f) {+ return function (s) {+ var v = Data_Newtype.unwrap(Data_Profunctor_Star.newtypeStar)(t(Data_Profunctor_Star.Star(function ($26) {+ return Data_Tuple.Tuple.create(true)(f($26));+ })))(s);+ if (v.value0) {+ return Control_Applicative.pure(dictAlternative.Applicative0())(v.value1);+ };+ if (!v.value0) {+ return Control_Plus.empty(dictAlternative.Plus1());+ };+ throw new Error("Failed pattern match at Data.Lens.Traversal line 55, column 18 - line 57, column 32: " + [ v.constructor.name ]);+ };+ };+ };+};+var elementsOf = function (dictWander) {+ return function (tr) {+ return function (pr) {+ return Data_Lens_Indexed.iwander(function (dictApplicative) {+ return function (f) {+ return Data_Newtype.unwrap(Data_Profunctor_Star.newtypeStar)(tr(Data_Lens_Internal_Wander.wanderStar(dictApplicative))(Data_Lens_Internal_Indexed.Indexed(Data_Profunctor_Star.Star(function (v) {+ var $21 = pr(v.value0);+ if ($21) {+ return f(v.value0)(v.value1);+ };+ return Control_Applicative.pure(dictApplicative)(v.value1);+ }))));+ };+ })(dictWander);+ };+ };+};+var element = function (dictWander) {+ return function (n) {+ return function (tr) {+ return Data_Lens_Indexed.unIndex((dictWander.Choice1()).Profunctor0())(elementsOf(dictWander)(function (dictWander1) {+ return Data_Lens_Indexed.positions(function (dictWander2) {+ return tr(dictWander2);+ })(dictWander1);+ })(function (v) {+ return v === n;+ }));+ };+ };+};+module.exports = {+ element: element, + elementsOf: elementsOf, + failover: failover, + itraverseOf: itraverseOf, + sequenceOf: sequenceOf, + traverseOf: traverseOf, + traversed: traversed+};++},{"../Control.Alternative":39,"../Control.Applicative":40,"../Control.Category":47,"../Control.Plus":91,"../Control.Semigroupoid":92,"../Data.Eq":138,"../Data.Function":149,"../Data.Lens.Indexed":170,"../Data.Lens.Internal.Indexed":174,"../Data.Lens.Internal.Wander":179,"../Data.Lens.Types":190,"../Data.Monoid.Disj":203,"../Data.Newtype":209,"../Data.Profunctor.Star":223,"../Data.Traversable":244,"../Data.Tuple":245,"../Prelude":268}],190:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Lens_Internal_Exchange = require("../Data.Lens.Internal.Exchange");+var Data_Lens_Internal_Forget = require("../Data.Lens.Internal.Forget");+var Data_Lens_Internal_Grating = require("../Data.Lens.Internal.Grating");+var Data_Lens_Internal_Indexed = require("../Data.Lens.Internal.Indexed");+var Data_Lens_Internal_Market = require("../Data.Lens.Internal.Market");+var Data_Lens_Internal_Re = require("../Data.Lens.Internal.Re");+var Data_Lens_Internal_Shop = require("../Data.Lens.Internal.Shop");+var Data_Lens_Internal_Tagged = require("../Data.Lens.Internal.Tagged");+var Data_Lens_Internal_Wander = require("../Data.Lens.Internal.Wander");+var Data_Profunctor = require("../Data.Profunctor");+var Data_Profunctor_Choice = require("../Data.Profunctor.Choice");+var Data_Profunctor_Closed = require("../Data.Profunctor.Closed");+var Data_Profunctor_Strong = require("../Data.Profunctor.Strong");+var Data_Tuple = require("../Data.Tuple");+module.exports = {};++},{"../Data.Lens.Internal.Exchange":171,"../Data.Lens.Internal.Forget":172,"../Data.Lens.Internal.Grating":173,"../Data.Lens.Internal.Indexed":174,"../Data.Lens.Internal.Market":175,"../Data.Lens.Internal.Re":176,"../Data.Lens.Internal.Shop":177,"../Data.Lens.Internal.Tagged":178,"../Data.Lens.Internal.Wander":179,"../Data.Profunctor":225,"../Data.Profunctor.Choice":218,"../Data.Profunctor.Closed":219,"../Data.Profunctor.Strong":224,"../Data.Tuple":245}],191:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Lens_Common = require("../Data.Lens.Common");+var Data_Lens_Fold = require("../Data.Lens.Fold");+var Data_Lens_Getter = require("../Data.Lens.Getter");+var Data_Lens_Grate = require("../Data.Lens.Grate");+var Data_Lens_Iso = require("../Data.Lens.Iso");+var Data_Lens_Lens = require("../Data.Lens.Lens");+var Data_Lens_Prism = require("../Data.Lens.Prism");+var Data_Lens_Setter = require("../Data.Lens.Setter");+var Data_Lens_Traversal = require("../Data.Lens.Traversal");+var Data_Lens_Types = require("../Data.Lens.Types");+module.exports = {};++},{"../Data.Lens.Common":166,"../Data.Lens.Fold":167,"../Data.Lens.Getter":168,"../Data.Lens.Grate":169,"../Data.Lens.Iso":181,"../Data.Lens.Lens":184,"../Data.Lens.Prism":187,"../Data.Lens.Setter":188,"../Data.Lens.Traversal":189,"../Data.Lens.Types":190}],192:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Bind = require("../Control.Bind");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Foldable = require("../Data.Foldable");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_List = require("../Data.List");+var Data_List_Types = require("../Data.List.Types");+var Data_Maybe = require("../Data.Maybe");+var Data_NonEmpty = require("../Data.NonEmpty");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Tuple = require("../Data.Tuple");+var Data_Unfoldable = require("../Data.Unfoldable");+var Prelude = require("../Prelude");+var uncons = function (v) {+ return {+ head: v.value0, + tail: v.value1+ };+};+var toList = function (v) {+ return new Data_List_Types.Cons(v.value0, v.value1);+};+var toUnfoldable = function (dictUnfoldable) {+ return function ($41) {+ return Data_Unfoldable.unfoldr(dictUnfoldable)(function (xs) {+ return Data_Functor.map(Data_Maybe.functorMaybe)(function (rec) {+ return new Data_Tuple.Tuple(rec.head, rec.tail);+ })(Data_List.uncons(xs));+ })(toList($41));+ };+};+var tail = function (v) {+ return v.value1;+};+var singleton = function ($42) {+ return Data_List_Types.NonEmptyList(Data_NonEmpty.singleton(Data_List_Types.plusList)($42));+};+var length = function (v) {+ return 1 + Data_List.length(v.value1) | 0;+};+var last = function (v) {+ return Data_Maybe.fromMaybe(v.value0)(Data_List.last(v.value1));+};+var init = function (v) {+ return Data_Maybe.maybe(Data_List_Types.Nil.value)(function (v1) {+ return new Data_List_Types.Cons(v.value0, v1);+ })(Data_List.init(v.value1));+};+var head = function (v) {+ return v.value0;+};+var fromList = function (v) {+ if (v instanceof Data_List_Types.Nil) {+ return Data_Maybe.Nothing.value;+ };+ if (v instanceof Data_List_Types.Cons) {+ return new Data_Maybe.Just(new Data_NonEmpty.NonEmpty(v.value0, v.value1));+ };+ throw new Error("Failed pattern match at Data.List.NonEmpty line 37, column 1 - line 37, column 25: " + [ v.constructor.name ]);+};+var fromFoldable = function (dictFoldable) {+ return function ($43) {+ return fromList(Data_List.fromFoldable(dictFoldable)($43));+ };+};+var concatMap = Data_Function.flip(Control_Bind.bind(Data_List_Types.bindNonEmptyList));+var appendFoldable = function (dictFoldable) {+ return function (v) {+ return function (ys) {+ return new Data_NonEmpty.NonEmpty(v.value0, Data_Semigroup.append(Data_List_Types.semigroupList)(v.value1)(Data_List.fromFoldable(dictFoldable)(ys)));+ };+ };+};+module.exports = {+ appendFoldable: appendFoldable, + concatMap: concatMap, + fromFoldable: fromFoldable, + fromList: fromList, + head: head, + init: init, + length: length, + singleton: singleton, + tail: tail, + toList: toList, + toUnfoldable: toUnfoldable, + uncons: uncons+};++},{"../Control.Bind":46,"../Control.Semigroupoid":92,"../Data.Foldable":143,"../Data.Function":149,"../Data.Functor":155,"../Data.List":194,"../Data.List.Types":193,"../Data.Maybe":198,"../Data.NonEmpty":210,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Tuple":245,"../Data.Unfoldable":247,"../Prelude":268}],193:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Control_Alternative = require("../Control.Alternative");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Category = require("../Control.Category");+var Control_Comonad = require("../Control.Comonad");+var Control_Extend = require("../Control.Extend");+var Control_Monad = require("../Control.Monad");+var Control_MonadPlus = require("../Control.MonadPlus");+var Control_MonadZero = require("../Control.MonadZero");+var Control_Plus = require("../Control.Plus");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Eq = require("../Data.Eq");+var Data_Foldable = require("../Data.Foldable");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Maybe = require("../Data.Maybe");+var Data_Monoid = require("../Data.Monoid");+var Data_Newtype = require("../Data.Newtype");+var Data_NonEmpty = require("../Data.NonEmpty");+var Data_Ord = require("../Data.Ord");+var Data_Ordering = require("../Data.Ordering");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Data_Traversable = require("../Data.Traversable");+var Data_Tuple = require("../Data.Tuple");+var Data_Unfoldable = require("../Data.Unfoldable");+var Prelude = require("../Prelude");+var Nil = (function () {+ function Nil() {++ };+ Nil.value = new Nil();+ return Nil;+})();+var Cons = (function () {+ function Cons(value0, value1) {+ this.value0 = value0;+ this.value1 = value1;+ };+ Cons.create = function (value0) {+ return function (value1) {+ return new Cons(value0, value1);+ };+ };+ return Cons;+})();+var NonEmptyList = function (x) {+ return x;+};+var toList = function (v) {+ return new Cons(v.value0, v.value1);+};+var newtypeNonEmptyList = new Data_Newtype.Newtype(function (n) {+ return n;+}, NonEmptyList);+var foldableList = new Data_Foldable.Foldable(function (dictMonoid) {+ return function (f) {+ return Data_Foldable.foldl(foldableList)(function (acc) {+ return function ($116) {+ return Data_Semigroup.append(dictMonoid.Semigroup0())(acc)(f($116));+ };+ })(Data_Monoid.mempty(dictMonoid));+ };+}, function (f) {+ var go = function (__copy_b) {+ return function (__copy_v) {+ var b = __copy_b;+ var v = __copy_v;+ var __tco_done = false;+ var __tco_result;+ var __tco_b;+ var __tco_v;+ function __tco_loop(b, v) {+ if (v instanceof Nil) {+ __tco_done = true;+ return b;+ };+ if (v instanceof Cons) {+ __tco_b = f(b)(v.value0);+ __tco_v = v.value1;+ return;+ };+ throw new Error("Failed pattern match at Data.List.Types line 76, column 12 - line 78, column 30: " + [ v.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(b, v);+ b = __tco_b;+ v = __tco_v;+ };+ return __tco_result;+ };+ };+ return go;+}, function (f) {+ return function (b) {+ var rev = function (__copy_acc) {+ return function (__copy_v) {+ var acc = __copy_acc;+ var v = __copy_v;+ var __tco_done = false;+ var __tco_result;+ var __tco_acc;+ var __tco_v;+ function __tco_loop(acc, v) {+ if (v instanceof Nil) {+ __tco_done = true;+ return acc;+ };+ if (v instanceof Cons) {+ __tco_acc = new Cons(v.value0, acc);+ __tco_v = v.value1;+ return;+ };+ throw new Error("Failed pattern match at Data.List.Types line 71, column 15 - line 73, column 33: " + [ v.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(acc, v);+ acc = __tco_acc;+ v = __tco_v;+ };+ return __tco_result;+ };+ };+ return function ($117) {+ return Data_Foldable.foldl(foldableList)(Data_Function.flip(f))(b)(rev(Nil.value)($117));+ };+ };+});+var foldableNonEmptyList = Data_NonEmpty.foldableNonEmpty(foldableList);+var functorList = new Data_Functor.Functor(function (f) {+ return Data_Foldable.foldr(foldableList)(function (x) {+ return function (acc) {+ return new Cons(f(x), acc);+ };+ })(Nil.value);+});+var functorNonEmptyList = Data_NonEmpty.functorNonEmpty(functorList);+var semigroupList = new Data_Semigroup.Semigroup(function (xs) {+ return function (ys) {+ return Data_Foldable.foldr(foldableList)(Cons.create)(ys)(xs);+ };+});+var monoidList = new Data_Monoid.Monoid(function () {+ return semigroupList;+}, Nil.value);+var semigroupNonEmptyList = new Data_Semigroup.Semigroup(function (v) {+ return function (as$prime) {+ return new Data_NonEmpty.NonEmpty(v.value0, Data_Semigroup.append(semigroupList)(v.value1)(toList(as$prime)));+ };+});+var showList = function (dictShow) {+ return new Data_Show.Show(function (v) {+ if (v instanceof Nil) {+ return "Nil";+ };+ return "(" + (Data_Foldable.intercalate(foldableList)(Data_Monoid.monoidString)(" : ")(Data_Functor.map(functorList)(Data_Show.show(dictShow))(v)) + " : Nil)");+ });+};+var showNonEmptyList = function (dictShow) {+ return new Data_Show.Show(function (v) {+ return "(NonEmptyList " + (Data_Show.show(Data_NonEmpty.showNonEmpty(dictShow)(showList(dictShow)))(v) + ")");+ });+};+var traversableList = new Data_Traversable.Traversable(function () {+ return foldableList;+}, function () {+ return functorList;+}, function (dictApplicative) {+ return Data_Traversable.traverse(traversableList)(dictApplicative)(Control_Category.id(Control_Category.categoryFn));+}, function (dictApplicative) {+ return function (f) {+ return function ($118) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Foldable.foldl(foldableList)(Data_Function.flip(Cons.create))(Nil.value))(Data_Foldable.foldl(foldableList)(function (acc) {+ return function ($119) {+ return Control_Apply.lift2(dictApplicative.Apply0())(Data_Function.flip(Cons.create))(acc)(f($119));+ };+ })(Control_Applicative.pure(dictApplicative)(Nil.value))($118));+ };+ };+});+var traversableNonEmptyList = Data_NonEmpty.traversableNonEmpty(traversableList);+var unfoldableList = new Data_Unfoldable.Unfoldable(function (f) {+ return function (b) {+ var go = function (__copy_source) {+ return function (__copy_memo) {+ var source = __copy_source;+ var memo = __copy_memo;+ var __tco_done = false;+ var __tco_result;+ var __tco_source;+ var __tco_memo;+ function __tco_loop(source, memo) {+ var v = f(source);+ if (v instanceof Data_Maybe.Nothing) {+ __tco_done = true;+ return Data_Foldable.foldl(foldableList)(Data_Function.flip(Cons.create))(Nil.value)(memo);+ };+ if (v instanceof Data_Maybe.Just) {+ __tco_source = v.value0.value1;+ __tco_memo = new Cons(v.value0.value0, memo);+ return;+ };+ throw new Error("Failed pattern match at Data.List.Types line 84, column 22 - line 86, column 52: " + [ v.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(source, memo);+ source = __tco_source;+ memo = __tco_memo;+ };+ return __tco_result;+ };+ };+ return go(b)(Nil.value);+ };+});+var extendNonEmptyList = new Control_Extend.Extend(function () {+ return functorNonEmptyList;+}, function (f) {+ return function (v) {+ var go = function (a) {+ return function (v1) {+ return {+ val: new Cons(f(new Data_NonEmpty.NonEmpty(a, v1.acc)), v1.val), + acc: new Cons(a, v1.acc)+ };+ };+ };+ return new Data_NonEmpty.NonEmpty(f(v), (Data_Foldable.foldr(foldableList)(go)({+ val: Nil.value, + acc: Nil.value+ })(v.value1)).val);+ };+});+var extendList = new Control_Extend.Extend(function () {+ return functorList;+}, function (f) {+ return function (v) {+ if (v instanceof Nil) {+ return Nil.value;+ };+ if (v instanceof Cons) {+ var go = function (a$prime) {+ return function (v1) {+ var acc$prime = new Cons(a$prime, v1.acc);+ return {+ val: new Cons(f(acc$prime), v1.val), + acc: acc$prime+ };+ };+ };+ return new Cons(f(v), (Data_Foldable.foldr(foldableList)(go)({+ val: Nil.value, + acc: Nil.value+ })(v.value1)).val);+ };+ throw new Error("Failed pattern match at Data.List.Types line 118, column 3 - line 118, column 21: " + [ f.constructor.name, v.constructor.name ]);+ };+});+var eq1List = new Data_Eq.Eq1(function (dictEq) {+ return function (xs) {+ return function (ys) {+ var go = function (__copy_v) {+ return function (__copy_v1) {+ return function (__copy_v2) {+ var v = __copy_v;+ var v1 = __copy_v1;+ var v2 = __copy_v2;+ var __tco_done = false;+ var __tco_result;+ var __tco_v;+ var __tco_v1;+ var __tco_v2;+ function __tco_loop(v, v1, v2) {+ if (!v2) {+ __tco_done = true;+ return false;+ };+ if (v instanceof Nil && v1 instanceof Nil) {+ __tco_done = true;+ return v2;+ };+ if (v instanceof Cons && v1 instanceof Cons) {+ __tco_v = v.value1;+ __tco_v1 = v1.value1;+ __tco_v2 = v2 && Data_Eq.eq(dictEq)(v1.value0)(v.value0);+ return;+ };+ __tco_done = true;+ return false;+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(v, v1, v2);+ v = __tco_v;+ v1 = __tco_v1;+ v2 = __tco_v2;+ };+ return __tco_result;+ };+ };+ };+ return go(xs)(ys)(true);+ };+ };+});+var eqList = function (dictEq) {+ return new Data_Eq.Eq(Data_Eq.eq1(eq1List)(dictEq));+};+var eqNonEmptyList = function (dictEq) {+ return Data_NonEmpty.eqNonEmpty(eq1List)(dictEq);+};+var ord1List = new Data_Ord.Ord1(function () {+ return eq1List;+}, function (dictOrd) {+ return function (xs) {+ return function (ys) {+ var go = function (__copy_v) {+ return function (__copy_v1) {+ var v = __copy_v;+ var v1 = __copy_v1;+ var __tco_done = false;+ var __tco_result;+ var __tco_v;+ var __tco_v1;+ function __tco_loop(v, v1) {+ if (v instanceof Nil && v1 instanceof Nil) {+ __tco_done = true;+ return Data_Ordering.EQ.value;+ };+ if (v instanceof Nil) {+ __tco_done = true;+ return Data_Ordering.LT.value;+ };+ if (v1 instanceof Nil) {+ __tco_done = true;+ return Data_Ordering.GT.value;+ };+ if (v instanceof Cons && v1 instanceof Cons) {+ var v2 = Data_Ord.compare(dictOrd)(v.value0)(v1.value0);+ if (v2 instanceof Data_Ordering.EQ) {+ __tco_v = v.value1;+ __tco_v1 = v1.value1;+ return;+ };+ __tco_done = true;+ return v2;+ };+ throw new Error("Failed pattern match at Data.List.Types line 49, column 20 - line 57, column 23: " + [ v.constructor.name, v1.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(v, v1);+ v = __tco_v;+ v1 = __tco_v1;+ };+ return __tco_result;+ };+ };+ return go(xs)(ys);+ };+ };+});+var ordList = function (dictOrd) {+ return new Data_Ord.Ord(function () {+ return eqList(dictOrd.Eq0());+ }, Data_Ord.compare1(ord1List)(dictOrd));+};+var ordNonEmptyList = function (dictOrd) {+ return Data_NonEmpty.ordNonEmpty(ord1List)(dictOrd);+};+var comonadNonEmptyList = new Control_Comonad.Comonad(function () {+ return extendNonEmptyList;+}, function (v) {+ return v.value0;+});+var applyList = new Control_Apply.Apply(function () {+ return functorList;+}, function (v) {+ return function (v1) {+ if (v instanceof Nil) {+ return Nil.value;+ };+ if (v instanceof Cons) {+ return Data_Semigroup.append(semigroupList)(Data_Functor.map(functorList)(v.value0)(v1))(Control_Apply.apply(applyList)(v.value1)(v1));+ };+ throw new Error("Failed pattern match at Data.List.Types line 93, column 3 - line 93, column 20: " + [ v.constructor.name, v1.constructor.name ]);+ };+});+var applyNonEmptyList = new Control_Apply.Apply(function () {+ return functorNonEmptyList;+}, function (v) {+ return function (v1) {+ return new Data_NonEmpty.NonEmpty(v.value0(v1.value0), Data_Semigroup.append(semigroupList)(Control_Apply.apply(applyList)(v.value1)(new Cons(v1.value0, Nil.value)))(Control_Apply.apply(applyList)(new Cons(v.value0, v.value1))(v1.value1)));+ };+});+var bindList = new Control_Bind.Bind(function () {+ return applyList;+}, function (v) {+ return function (v1) {+ if (v instanceof Nil) {+ return Nil.value;+ };+ if (v instanceof Cons) {+ return Data_Semigroup.append(semigroupList)(v1(v.value0))(Control_Bind.bind(bindList)(v.value1)(v1));+ };+ throw new Error("Failed pattern match at Data.List.Types line 100, column 3 - line 100, column 19: " + [ v.constructor.name, v1.constructor.name ]);+ };+});+var bindNonEmptyList = new Control_Bind.Bind(function () {+ return applyNonEmptyList;+}, function (v) {+ return function (f) {+ var v1 = f(v.value0);+ return new Data_NonEmpty.NonEmpty(v1.value0, Data_Semigroup.append(semigroupList)(v1.value1)(Control_Bind.bind(bindList)(v.value1)(function ($120) {+ return toList(f($120));+ })));+ };+});+var applicativeList = new Control_Applicative.Applicative(function () {+ return applyList;+}, function (a) {+ return new Cons(a, Nil.value);+});+var monadList = new Control_Monad.Monad(function () {+ return applicativeList;+}, function () {+ return bindList;+});+var altNonEmptyList = new Control_Alt.Alt(function () {+ return functorNonEmptyList;+}, Data_Semigroup.append(semigroupNonEmptyList));+var altList = new Control_Alt.Alt(function () {+ return functorList;+}, Data_Semigroup.append(semigroupList));+var plusList = new Control_Plus.Plus(function () {+ return altList;+}, Nil.value);+var alternativeList = new Control_Alternative.Alternative(function () {+ return applicativeList;+}, function () {+ return plusList;+});+var monadZeroList = new Control_MonadZero.MonadZero(function () {+ return alternativeList;+}, function () {+ return monadList;+});+var monadPlusList = new Control_MonadPlus.MonadPlus(function () {+ return monadZeroList;+});+var applicativeNonEmptyList = new Control_Applicative.Applicative(function () {+ return applyNonEmptyList;+}, function ($121) {+ return NonEmptyList(Data_NonEmpty.singleton(plusList)($121));+});+var monadNonEmptyList = new Control_Monad.Monad(function () {+ return applicativeNonEmptyList;+}, function () {+ return bindNonEmptyList;+});+module.exports = {+ Nil: Nil, + Cons: Cons, + NonEmptyList: NonEmptyList, + toList: toList, + showList: showList, + eqList: eqList, + eq1List: eq1List, + ordList: ordList, + ord1List: ord1List, + semigroupList: semigroupList, + monoidList: monoidList, + functorList: functorList, + foldableList: foldableList, + unfoldableList: unfoldableList, + traversableList: traversableList, + applyList: applyList, + applicativeList: applicativeList, + bindList: bindList, + monadList: monadList, + altList: altList, + plusList: plusList, + alternativeList: alternativeList, + monadZeroList: monadZeroList, + monadPlusList: monadPlusList, + extendList: extendList, + newtypeNonEmptyList: newtypeNonEmptyList, + eqNonEmptyList: eqNonEmptyList, + ordNonEmptyList: ordNonEmptyList, + showNonEmptyList: showNonEmptyList, + functorNonEmptyList: functorNonEmptyList, + applyNonEmptyList: applyNonEmptyList, + applicativeNonEmptyList: applicativeNonEmptyList, + bindNonEmptyList: bindNonEmptyList, + monadNonEmptyList: monadNonEmptyList, + altNonEmptyList: altNonEmptyList, + extendNonEmptyList: extendNonEmptyList, + comonadNonEmptyList: comonadNonEmptyList, + semigroupNonEmptyList: semigroupNonEmptyList, + foldableNonEmptyList: foldableNonEmptyList, + traversableNonEmptyList: traversableNonEmptyList+};++},{"../Control.Alt":38,"../Control.Alternative":39,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Category":47,"../Control.Comonad":48,"../Control.Extend":49,"../Control.Monad":86,"../Control.MonadPlus":87,"../Control.MonadZero":88,"../Control.Plus":91,"../Control.Semigroupoid":92,"../Data.Eq":138,"../Data.Foldable":143,"../Data.Function":149,"../Data.Functor":155,"../Data.HeytingAlgebra":160,"../Data.Maybe":198,"../Data.Monoid":207,"../Data.Newtype":209,"../Data.NonEmpty":210,"../Data.Ord":216,"../Data.Ordering":217,"../Data.Semigroup":229,"../Data.Show":233,"../Data.Traversable":244,"../Data.Tuple":245,"../Data.Unfoldable":247,"../Prelude":268}],194:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Control_Alternative = require("../Control.Alternative");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Category = require("../Control.Category");+var Control_Lazy = require("../Control.Lazy");+var Control_Monad_Rec_Class = require("../Control.Monad.Rec.Class");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Bifunctor = require("../Data.Bifunctor");+var Data_Boolean = require("../Data.Boolean");+var Data_Eq = require("../Data.Eq");+var Data_Foldable = require("../Data.Foldable");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_List_Types = require("../Data.List.Types");+var Data_Maybe = require("../Data.Maybe");+var Data_NonEmpty = require("../Data.NonEmpty");+var Data_Ord = require("../Data.Ord");+var Data_Ordering = require("../Data.Ordering");+var Data_Ring = require("../Data.Ring");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Traversable = require("../Data.Traversable");+var Data_Tuple = require("../Data.Tuple");+var Data_Unfoldable = require("../Data.Unfoldable");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var updateAt = function (v) {+ return function (v1) {+ return function (v2) {+ if (v === 0 && v2 instanceof Data_List_Types.Cons) {+ return new Data_Maybe.Just(new Data_List_Types.Cons(v1, v2.value1));+ };+ if (v2 instanceof Data_List_Types.Cons) {+ return Data_Functor.map(Data_Maybe.functorMaybe)(function (v3) {+ return new Data_List_Types.Cons(v2.value0, v3);+ })(updateAt(v - 1 | 0)(v1)(v2.value1));+ };+ return Data_Maybe.Nothing.value;+ };+ };+};+var unzip = Data_Foldable.foldr(Data_List_Types.foldableList)(function (v) {+ return function (v1) {+ return new Data_Tuple.Tuple(new Data_List_Types.Cons(v.value0, v1.value0), new Data_List_Types.Cons(v.value1, v1.value1));+ };+})(new Data_Tuple.Tuple(Data_List_Types.Nil.value, Data_List_Types.Nil.value));+var uncons = function (v) {+ if (v instanceof Data_List_Types.Nil) {+ return Data_Maybe.Nothing.value;+ };+ if (v instanceof Data_List_Types.Cons) {+ return new Data_Maybe.Just({+ head: v.value0, + tail: v.value1+ });+ };+ throw new Error("Failed pattern match at Data.List line 253, column 1 - line 253, column 21: " + [ v.constructor.name ]);+};+var toUnfoldable = function (dictUnfoldable) {+ return Data_Unfoldable.unfoldr(dictUnfoldable)(function (xs) {+ return Data_Functor.map(Data_Maybe.functorMaybe)(function (rec) {+ return new Data_Tuple.Tuple(rec.head, rec.tail);+ })(uncons(xs));+ });+};+var tail = function (v) {+ if (v instanceof Data_List_Types.Nil) {+ return Data_Maybe.Nothing.value;+ };+ if (v instanceof Data_List_Types.Cons) {+ return new Data_Maybe.Just(v.value1);+ };+ throw new Error("Failed pattern match at Data.List line 239, column 1 - line 239, column 19: " + [ v.constructor.name ]);+};+var span = function (v) {+ return function (v1) {+ if (v1 instanceof Data_List_Types.Cons && v(v1.value0)) {+ var v2 = span(v)(v1.value1);+ return {+ init: new Data_List_Types.Cons(v1.value0, v2.init), + rest: v2.rest+ };+ };+ return {+ init: Data_List_Types.Nil.value, + rest: v1+ };+ };+};+var singleton = function (a) {+ return new Data_List_Types.Cons(a, Data_List_Types.Nil.value);+};+var sortBy = function (cmp) {+ var merge = function (v) {+ return function (v1) {+ if (v instanceof Data_List_Types.Cons && v1 instanceof Data_List_Types.Cons) {+ if (Data_Eq.eq(Data_Ordering.eqOrdering)(cmp(v.value0)(v1.value0))(Data_Ordering.GT.value)) {+ return new Data_List_Types.Cons(v1.value0, merge(v)(v1.value1));+ };+ if (Data_Boolean.otherwise) {+ return new Data_List_Types.Cons(v.value0, merge(v.value1)(v1));+ };+ };+ if (v instanceof Data_List_Types.Nil) {+ return v1;+ };+ if (v1 instanceof Data_List_Types.Nil) {+ return v;+ };+ throw new Error("Failed pattern match at Data.List line 468, column 3 - line 470, column 41: " + [ v.constructor.name, v1.constructor.name ]);+ };+ };+ var mergePairs = function (v) {+ if (v instanceof Data_List_Types.Cons && v.value1 instanceof Data_List_Types.Cons) {+ return new Data_List_Types.Cons(merge(v.value0)(v.value1.value0), mergePairs(v.value1.value1));+ };+ return v;+ };+ var mergeAll = function (__copy_v) {+ var v = __copy_v;+ var __tco_done = false;+ var __tco_result;+ var __tco_v;+ function __tco_loop(v) {+ if (v instanceof Data_List_Types.Cons && v.value1 instanceof Data_List_Types.Nil) {+ __tco_done = true;+ return v.value0;+ };+ __tco_v = mergePairs(v);+ return;+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(v);+ v = __tco_v;+ };+ return __tco_result;+ };+ var sequences = function (v) {+ if (v instanceof Data_List_Types.Cons && v.value1 instanceof Data_List_Types.Cons) {+ if (Data_Eq.eq(Data_Ordering.eqOrdering)(cmp(v.value0)(v.value1.value0))(Data_Ordering.GT.value)) {+ return descending(v.value1.value0)(singleton(v.value0))(v.value1.value1);+ };+ if (Data_Boolean.otherwise) {+ return ascending(v.value1.value0)(function (v1) {+ return new Data_List_Types.Cons(v.value0, v1);+ })(v.value1.value1);+ };+ };+ return singleton(v);+ };+ var descending = function (__copy_a) {+ return function (__copy_as) {+ return function (__copy_v) {+ var a = __copy_a;+ var as = __copy_as;+ var v = __copy_v;+ var __tco_done = false;+ var __tco_result;+ var __tco_a;+ var __tco_as;+ var __tco_v;+ function __tco_loop(a, as, v) {+ if (v instanceof Data_List_Types.Cons && Data_Eq.eq(Data_Ordering.eqOrdering)(cmp(a)(v.value0))(Data_Ordering.GT.value)) {+ __tco_a = v.value0;+ __tco_as = new Data_List_Types.Cons(a, as);+ __tco_v = v.value1;+ return;+ };+ __tco_done = true;+ return new Data_List_Types.Cons(new Data_List_Types.Cons(a, as), sequences(v));+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(a, as, v);+ a = __tco_a;+ as = __tco_as;+ v = __tco_v;+ };+ return __tco_result;+ };+ };+ };+ var ascending = function (__copy_a) {+ return function (__copy_as) {+ return function (__copy_v) {+ var a = __copy_a;+ var as = __copy_as;+ var v = __copy_v;+ var __tco_done = false;+ var __tco_result;+ var __tco_a;+ var __tco_as;+ var __tco_v;+ function __tco_loop(a, as, v) {+ if (v instanceof Data_List_Types.Cons && Data_Eq.notEq(Data_Ordering.eqOrdering)(cmp(a)(v.value0))(Data_Ordering.GT.value)) {+ __tco_a = v.value0;+ __tco_as = function (ys) {+ return as(new Data_List_Types.Cons(a, ys));+ };+ __tco_v = v.value1;+ return;+ };+ __tco_done = true;+ return new Data_List_Types.Cons(as(singleton(a)), sequences(v));+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(a, as, v);+ a = __tco_a;+ as = __tco_as;+ v = __tco_v;+ };+ return __tco_result;+ };+ };+ };+ return function ($304) {+ return mergeAll(sequences($304));+ };+};+var sort = function (dictOrd) {+ return function (xs) {+ return sortBy(Data_Ord.compare(dictOrd))(xs);+ };+};+var reverse = (function () {+ var go = function (__copy_acc) {+ return function (__copy_v) {+ var acc = __copy_acc;+ var v = __copy_v;+ var __tco_done = false;+ var __tco_result;+ var __tco_acc;+ var __tco_v;+ function __tco_loop(acc, v) {+ if (v instanceof Data_List_Types.Nil) {+ __tco_done = true;+ return acc;+ };+ if (v instanceof Data_List_Types.Cons) {+ __tco_acc = new Data_List_Types.Cons(v.value0, acc);+ __tco_v = v.value1;+ return;+ };+ throw new Error("Failed pattern match at Data.List line 359, column 11 - line 362, column 36: " + [ acc.constructor.name, v.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(acc, v);+ acc = __tco_acc;+ v = __tco_v;+ };+ return __tco_result;+ };+ };+ return go(Data_List_Types.Nil.value);+})();+var snoc = function (xs) {+ return function (x) {+ return reverse(new Data_List_Types.Cons(x, reverse(xs)));+ };+};+var take = (function () {+ var go = function (__copy_acc) {+ return function (__copy_v) {+ return function (__copy_v1) {+ var acc = __copy_acc;+ var v = __copy_v;+ var v1 = __copy_v1;+ var __tco_done = false;+ var __tco_result;+ var __tco_acc;+ var __tco_v;+ var __tco_v1;+ function __tco_loop(acc, v, v1) {+ if (v === 0) {+ __tco_done = true;+ return reverse(acc);+ };+ if (v1 instanceof Data_List_Types.Nil) {+ __tco_done = true;+ return reverse(acc);+ };+ if (v1 instanceof Data_List_Types.Cons) {+ __tco_acc = new Data_List_Types.Cons(v1.value0, acc);+ __tco_v = v - 1 | 0;+ __tco_v1 = v1.value1;+ return;+ };+ throw new Error("Failed pattern match at Data.List line 486, column 8 - line 490, column 46: " + [ acc.constructor.name, v.constructor.name, v1.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(acc, v, v1);+ acc = __tco_acc;+ v = __tco_v;+ v1 = __tco_v1;+ };+ return __tco_result;+ };+ };+ };+ return go(Data_List_Types.Nil.value);+})();+var takeWhile = function (p) {+ var go = function (__copy_acc) {+ return function (__copy_v) {+ var acc = __copy_acc;+ var v = __copy_v;+ var __tco_done = false;+ var __tco_result;+ var __tco_acc;+ var __tco_v;+ function __tco_loop(acc, v) {+ if (v instanceof Data_List_Types.Cons && p(v.value0)) {+ __tco_acc = new Data_List_Types.Cons(v.value0, acc);+ __tco_v = v.value1;+ return;+ };+ __tco_done = true;+ return reverse(acc);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(acc, v);+ acc = __tco_acc;+ v = __tco_v;+ };+ return __tco_result;+ };+ };+ return go(Data_List_Types.Nil.value);+};+var unsnoc = function (lst) {+ var go = function (__copy_v) {+ return function (__copy_acc) {+ var v = __copy_v;+ var acc = __copy_acc;+ var __tco_done = false;+ var __tco_result;+ var __tco_v;+ var __tco_acc;+ function __tco_loop(v, acc) {+ if (v instanceof Data_List_Types.Nil) {+ __tco_done = true;+ return Data_Maybe.Nothing.value;+ };+ if (v instanceof Data_List_Types.Cons && v.value1 instanceof Data_List_Types.Nil) {+ __tco_done = true;+ return new Data_Maybe.Just({+ revInit: acc, + last: v.value0+ });+ };+ if (v instanceof Data_List_Types.Cons) {+ __tco_v = v.value1;+ __tco_acc = new Data_List_Types.Cons(v.value0, acc);+ return;+ };+ throw new Error("Failed pattern match at Data.List line 261, column 14 - line 265, column 36: " + [ v.constructor.name, acc.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(v, acc);+ v = __tco_v;+ acc = __tco_acc;+ };+ return __tco_result;+ };+ };+ return Data_Functor.map(Data_Maybe.functorMaybe)(function (h) {+ return {+ init: reverse(h.revInit), + last: h.last+ };+ })(go(lst)(Data_List_Types.Nil.value));+};+var zipWith = function (f) {+ return function (xs) {+ return function (ys) {+ var go = function (__copy_v) {+ return function (__copy_v1) {+ return function (__copy_acc) {+ var v = __copy_v;+ var v1 = __copy_v1;+ var acc = __copy_acc;+ var __tco_done = false;+ var __tco_result;+ var __tco_v;+ var __tco_v1;+ var __tco_acc;+ function __tco_loop(v, v1, acc) {+ if (v instanceof Data_List_Types.Nil) {+ __tco_done = true;+ return acc;+ };+ if (v1 instanceof Data_List_Types.Nil) {+ __tco_done = true;+ return acc;+ };+ if (v instanceof Data_List_Types.Cons && v1 instanceof Data_List_Types.Cons) {+ __tco_v = v.value1;+ __tco_v1 = v1.value1;+ __tco_acc = new Data_List_Types.Cons(f(v.value0)(v1.value0), acc);+ return;+ };+ throw new Error("Failed pattern match at Data.List line 650, column 19 - line 654, column 52: " + [ v.constructor.name, v1.constructor.name, acc.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(v, v1, acc);+ v = __tco_v;+ v1 = __tco_v1;+ acc = __tco_acc;+ };+ return __tco_result;+ };+ };+ };+ return reverse(go(xs)(ys)(Data_List_Types.Nil.value));+ };+ };+};+var zip = zipWith(Data_Tuple.Tuple.create);+var zipWithA = function (dictApplicative) {+ return function (f) {+ return function (xs) {+ return function (ys) {+ return Data_Traversable.sequence(Data_List_Types.traversableList)(dictApplicative)(zipWith(f)(xs)(ys));+ };+ };+ };+};+var range = function (start) {+ return function (end) {+ if (start === end) {+ return singleton(start);+ };+ if (Data_Boolean.otherwise) {+ var go = function (__copy_s) {+ return function (__copy_e) {+ return function (__copy_step) {+ return function (__copy_rest) {+ var s = __copy_s;+ var e = __copy_e;+ var step = __copy_step;+ var rest = __copy_rest;+ var __tco_done = false;+ var __tco_result;+ var __tco_s;+ var __tco_e;+ var __tco_step;+ var __tco_rest;+ function __tco_loop(s, e, step, rest) {+ if (s === e) {+ __tco_done = true;+ return new Data_List_Types.Cons(s, rest);+ };+ if (Data_Boolean.otherwise) {+ __tco_s = s + step | 0;+ __tco_e = e;+ __tco_step = step;+ __tco_rest = new Data_List_Types.Cons(s, rest);+ return;+ };+ throw new Error("Failed pattern match at Data.List line 139, column 31 - line 142, column 65: " + [ s.constructor.name, e.constructor.name, step.constructor.name, rest.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(s, e, step, rest);+ s = __tco_s;+ e = __tco_e;+ step = __tco_step;+ rest = __tco_rest;+ };+ return __tco_result;+ };+ };+ };+ };+ return go(end)(start)((function () {+ var $195 = start > end;+ if ($195) {+ return 1;+ };+ return -1 | 0;+ })())(Data_List_Types.Nil.value);+ };+ throw new Error("Failed pattern match at Data.List line 138, column 1 - line 142, column 65: " + [ start.constructor.name, end.constructor.name ]);+ };+};+var $$null = function (v) {+ if (v instanceof Data_List_Types.Nil) {+ return true;+ };+ return false;+};+var mapWithIndex = function (f) {+ return function (lst) {+ var go = function (__copy_v) {+ return function (__copy_v1) {+ return function (__copy_acc) {+ var v = __copy_v;+ var v1 = __copy_v1;+ var acc = __copy_acc;+ var __tco_done = false;+ var __tco_result;+ var __tco_v;+ var __tco_v1;+ var __tco_acc;+ function __tco_loop(v, v1, acc) {+ if (v1 instanceof Data_List_Types.Nil) {+ __tco_done = true;+ return acc;+ };+ if (v1 instanceof Data_List_Types.Cons) {+ __tco_v = v + 1 | 0;+ __tco_v1 = v1.value1;+ __tco_acc = new Data_List_Types.Cons(f(v)(v1.value0), acc);+ return;+ };+ throw new Error("Failed pattern match at Data.List line 424, column 22 - line 427, column 48: " + [ v.constructor.name, v1.constructor.name, acc.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(v, v1, acc);+ v = __tco_v;+ v1 = __tco_v1;+ acc = __tco_acc;+ };+ return __tco_result;+ };+ };+ };+ return reverse(go(0)(lst)(Data_List_Types.Nil.value));+ };+};+var mapMaybe = function (f) {+ var go = function (__copy_acc) {+ return function (__copy_v) {+ var acc = __copy_acc;+ var v = __copy_v;+ var __tco_done = false;+ var __tco_result;+ var __tco_acc;+ var __tco_v;+ function __tco_loop(acc, v) {+ if (v instanceof Data_List_Types.Nil) {+ __tco_done = true;+ return reverse(acc);+ };+ if (v instanceof Data_List_Types.Cons) {+ var v1 = f(v.value0);+ if (v1 instanceof Data_Maybe.Nothing) {+ __tco_acc = acc;+ __tco_v = v.value1;+ return;+ };+ if (v1 instanceof Data_Maybe.Just) {+ __tco_acc = new Data_List_Types.Cons(v1.value0, acc);+ __tco_v = v.value1;+ return;+ };+ throw new Error("Failed pattern match at Data.List line 412, column 5 - line 414, column 32: " + [ v1.constructor.name ]);+ };+ throw new Error("Failed pattern match at Data.List line 408, column 14 - line 414, column 32: " + [ acc.constructor.name, v.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(acc, v);+ acc = __tco_acc;+ v = __tco_v;+ };+ return __tco_result;+ };+ };+ return go(Data_List_Types.Nil.value);+};+var manyRec = function (dictMonadRec) {+ return function (dictAlternative) {+ return function (p) {+ var go = function (acc) {+ return Control_Bind.bind((dictMonadRec.Monad0()).Bind1())(Control_Alt.alt((dictAlternative.Plus1()).Alt0())(Data_Functor.map(((dictAlternative.Plus1()).Alt0()).Functor0())(Control_Monad_Rec_Class.Loop.create)(p))(Control_Applicative.pure(dictAlternative.Applicative0())(new Control_Monad_Rec_Class.Done(Data_Unit.unit))))(function (v) {+ return Control_Applicative.pure(dictAlternative.Applicative0())(Data_Bifunctor.bimap(Control_Monad_Rec_Class.bifunctorStep)(function (v1) {+ return new Data_List_Types.Cons(v1, acc);+ })(function (v1) {+ return reverse(acc);+ })(v));+ });+ };+ return Control_Monad_Rec_Class.tailRecM(dictMonadRec)(go)(Data_List_Types.Nil.value);+ };+ };+};+var someRec = function (dictMonadRec) {+ return function (dictAlternative) {+ return function (v) {+ return Control_Apply.apply((dictAlternative.Applicative0()).Apply0())(Data_Functor.map(((dictAlternative.Plus1()).Alt0()).Functor0())(Data_List_Types.Cons.create)(v))(manyRec(dictMonadRec)(dictAlternative)(v));+ };+ };+};+var some = function (dictAlternative) {+ return function (dictLazy) {+ return function (v) {+ return Control_Apply.apply((dictAlternative.Applicative0()).Apply0())(Data_Functor.map(((dictAlternative.Plus1()).Alt0()).Functor0())(Data_List_Types.Cons.create)(v))(Control_Lazy.defer(dictLazy)(function (v1) {+ return many(dictAlternative)(dictLazy)(v);+ }));+ };+ };+};+var many = function (dictAlternative) {+ return function (dictLazy) {+ return function (v) {+ return Control_Alt.alt((dictAlternative.Plus1()).Alt0())(some(dictAlternative)(dictLazy)(v))(Control_Applicative.pure(dictAlternative.Applicative0())(Data_List_Types.Nil.value));+ };+ };+};+var length = Data_Foldable.foldl(Data_List_Types.foldableList)(function (acc) {+ return function (v) {+ return acc + 1 | 0;+ };+})(0);+var last = function (__copy_v) {+ var v = __copy_v;+ var __tco_done = false;+ var __tco_result;+ var __tco_v;+ function __tco_loop(v) {+ if (v instanceof Data_List_Types.Cons && v.value1 instanceof Data_List_Types.Nil) {+ __tco_done = true;+ return new Data_Maybe.Just(v.value0);+ };+ if (v instanceof Data_List_Types.Cons) {+ __tco_v = v.value1;+ return;+ };+ __tco_done = true;+ return Data_Maybe.Nothing.value;+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(v);+ v = __tco_v;+ };+ return __tco_result;+};+var insertBy = function (v) {+ return function (x) {+ return function (v1) {+ if (v1 instanceof Data_List_Types.Nil) {+ return singleton(x);+ };+ if (v1 instanceof Data_List_Types.Cons) {+ var v2 = v(x)(v1.value0);+ if (v2 instanceof Data_Ordering.GT) {+ return new Data_List_Types.Cons(v1.value0, insertBy(v)(x)(v1.value1));+ };+ return new Data_List_Types.Cons(x, v1);+ };+ throw new Error("Failed pattern match at Data.List line 210, column 1 - line 210, column 31: " + [ v.constructor.name, x.constructor.name, v1.constructor.name ]);+ };+ };+};+var insertAt = function (v) {+ return function (v1) {+ return function (v2) {+ if (v === 0) {+ return new Data_Maybe.Just(new Data_List_Types.Cons(v1, v2));+ };+ if (v2 instanceof Data_List_Types.Cons) {+ return Data_Functor.map(Data_Maybe.functorMaybe)(function (v3) {+ return new Data_List_Types.Cons(v2.value0, v3);+ })(insertAt(v - 1 | 0)(v1)(v2.value1));+ };+ return Data_Maybe.Nothing.value;+ };+ };+};+var insert = function (dictOrd) {+ return insertBy(Data_Ord.compare(dictOrd));+};+var init = function (lst) {+ return Data_Functor.map(Data_Maybe.functorMaybe)(function (v) {+ return v.init;+ })(unsnoc(lst));+};+var index = function (__copy_v) {+ return function (__copy_v1) {+ var v = __copy_v;+ var v1 = __copy_v1;+ var __tco_done = false;+ var __tco_result;+ var __tco_v;+ var __tco_v1;+ function __tco_loop(v, v1) {+ if (v instanceof Data_List_Types.Nil) {+ __tco_done = true;+ return Data_Maybe.Nothing.value;+ };+ if (v instanceof Data_List_Types.Cons && v1 === 0) {+ __tco_done = true;+ return new Data_Maybe.Just(v.value0);+ };+ if (v instanceof Data_List_Types.Cons) {+ __tco_v = v.value1;+ __tco_v1 = v1 - 1 | 0;+ return;+ };+ throw new Error("Failed pattern match at Data.List line 275, column 1 - line 275, column 22: " + [ v.constructor.name, v1.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(v, v1);+ v = __tco_v;+ v1 = __tco_v1;+ };+ return __tco_result;+ };+};+var head = function (v) {+ if (v instanceof Data_List_Types.Nil) {+ return Data_Maybe.Nothing.value;+ };+ if (v instanceof Data_List_Types.Cons) {+ return new Data_Maybe.Just(v.value0);+ };+ throw new Error("Failed pattern match at Data.List line 224, column 1 - line 224, column 19: " + [ v.constructor.name ]);+};+var transpose = function (v) {+ if (v instanceof Data_List_Types.Nil) {+ return Data_List_Types.Nil.value;+ };+ if (v instanceof Data_List_Types.Cons && v.value0 instanceof Data_List_Types.Nil) {+ return transpose(v.value1);+ };+ if (v instanceof Data_List_Types.Cons && v.value0 instanceof Data_List_Types.Cons) {+ return new Data_List_Types.Cons(new Data_List_Types.Cons(v.value0.value0, mapMaybe(head)(v.value1)), transpose(new Data_List_Types.Cons(v.value0.value1, mapMaybe(tail)(v.value1))));+ };+ throw new Error("Failed pattern match at Data.List line 687, column 1 - line 687, column 20: " + [ v.constructor.name ]);+};+var groupBy = function (v) {+ return function (v1) {+ if (v1 instanceof Data_List_Types.Nil) {+ return Data_List_Types.Nil.value;+ };+ if (v1 instanceof Data_List_Types.Cons) {+ var v2 = span(v(v1.value0))(v1.value1);+ return new Data_List_Types.Cons(new Data_NonEmpty.NonEmpty(v1.value0, v2.init), groupBy(v)(v2.rest));+ };+ throw new Error("Failed pattern match at Data.List line 560, column 1 - line 560, column 20: " + [ v.constructor.name, v1.constructor.name ]);+ };+};+var group = function (dictEq) {+ return groupBy(Data_Eq.eq(dictEq));+};+var group$prime = function (dictOrd) {+ return function ($305) {+ return group(dictOrd.Eq0())(sort(dictOrd)($305));+ };+};+var fromFoldable = function (dictFoldable) {+ return Data_Foldable.foldr(dictFoldable)(Data_List_Types.Cons.create)(Data_List_Types.Nil.value);+};+var foldM = function (dictMonad) {+ return function (v) {+ return function (a) {+ return function (v1) {+ if (v1 instanceof Data_List_Types.Nil) {+ return Control_Applicative.pure(dictMonad.Applicative0())(a);+ };+ if (v1 instanceof Data_List_Types.Cons) {+ return Control_Bind.bind(dictMonad.Bind1())(v(a)(v1.value0))(function (a$prime) {+ return foldM(dictMonad)(v)(a$prime)(v1.value1);+ });+ };+ throw new Error("Failed pattern match at Data.List line 698, column 1 - line 698, column 23: " + [ v.constructor.name, a.constructor.name, v1.constructor.name ]);+ };+ };+ };+};+var findIndex = function (fn) {+ var go = function (__copy_v) {+ return function (__copy_v1) {+ var v = __copy_v;+ var v1 = __copy_v1;+ var __tco_done = false;+ var __tco_result;+ var __tco_v;+ var __tco_v1;+ function __tco_loop(v, v1) {+ if (v1 instanceof Data_List_Types.Cons) {+ if (fn(v1.value0)) {+ __tco_done = true;+ return new Data_Maybe.Just(v);+ };+ if (Data_Boolean.otherwise) {+ __tco_v = v + 1 | 0;+ __tco_v1 = v1.value1;+ return;+ };+ };+ if (v1 instanceof Data_List_Types.Nil) {+ __tco_done = true;+ return Data_Maybe.Nothing.value;+ };+ throw new Error("Failed pattern match at Data.List line 295, column 3 - line 296, column 44: " + [ v.constructor.name, v1.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(v, v1);+ v = __tco_v;+ v1 = __tco_v1;+ };+ return __tco_result;+ };+ };+ return go(0);+};+var findLastIndex = function (fn) {+ return function (xs) {+ return Data_Functor.map(Data_Maybe.functorMaybe)(function (v) {+ return (length(xs) - 1 | 0) - v | 0;+ })(findIndex(fn)(reverse(xs)));+ };+};+var filterM = function (dictMonad) {+ return function (v) {+ return function (v1) {+ if (v1 instanceof Data_List_Types.Nil) {+ return Control_Applicative.pure(dictMonad.Applicative0())(Data_List_Types.Nil.value);+ };+ if (v1 instanceof Data_List_Types.Cons) {+ return Control_Bind.bind(dictMonad.Bind1())(v(v1.value0))(function (v2) {+ return Control_Bind.bind(dictMonad.Bind1())(filterM(dictMonad)(v)(v1.value1))(function (v3) {+ return Control_Applicative.pure(dictMonad.Applicative0())((function () {+ if (v2) {+ return new Data_List_Types.Cons(v1.value0, v3);+ };+ return v3;+ })());+ });+ });+ };+ throw new Error("Failed pattern match at Data.List line 397, column 1 - line 397, column 25: " + [ v.constructor.name, v1.constructor.name ]);+ };+ };+};+var filter = function (p) {+ var go = function (__copy_acc) {+ return function (__copy_v) {+ var acc = __copy_acc;+ var v = __copy_v;+ var __tco_done = false;+ var __tco_result;+ var __tco_acc;+ var __tco_v;+ function __tco_loop(acc, v) {+ if (v instanceof Data_List_Types.Nil) {+ __tco_done = true;+ return reverse(acc);+ };+ if (v instanceof Data_List_Types.Cons) {+ if (p(v.value0)) {+ __tco_acc = new Data_List_Types.Cons(v.value0, acc);+ __tco_v = v.value1;+ return;+ };+ if (Data_Boolean.otherwise) {+ __tco_acc = acc;+ __tco_v = v.value1;+ return;+ };+ };+ throw new Error("Failed pattern match at Data.List line 381, column 12 - line 386, column 28: " + [ acc.constructor.name, v.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(acc, v);+ acc = __tco_acc;+ v = __tco_v;+ };+ return __tco_result;+ };+ };+ return go(Data_List_Types.Nil.value);+};+var intersectBy = function (v) {+ return function (v1) {+ return function (v2) {+ if (v1 instanceof Data_List_Types.Nil) {+ return Data_List_Types.Nil.value;+ };+ if (v2 instanceof Data_List_Types.Nil) {+ return Data_List_Types.Nil.value;+ };+ return filter(function (x) {+ return Data_Foldable.any(Data_List_Types.foldableList)(Data_HeytingAlgebra.heytingAlgebraBoolean)(v(x))(v2);+ })(v1);+ };+ };+};+var intersect = function (dictEq) {+ return intersectBy(Data_Eq.eq(dictEq));+};+var nubBy = function (v) {+ return function (v1) {+ if (v1 instanceof Data_List_Types.Nil) {+ return Data_List_Types.Nil.value;+ };+ if (v1 instanceof Data_List_Types.Cons) {+ return new Data_List_Types.Cons(v1.value0, nubBy(v)(filter(function (y) {+ return !v(v1.value0)(y);+ })(v1.value1)));+ };+ throw new Error("Failed pattern match at Data.List line 579, column 1 - line 579, column 22: " + [ v.constructor.name, v1.constructor.name ]);+ };+};+var nub = function (dictEq) {+ return nubBy(Data_Eq.eq(dictEq));+};+var elemLastIndex = function (dictEq) {+ return function (x) {+ return findLastIndex(function (v) {+ return Data_Eq.eq(dictEq)(v)(x);+ });+ };+};+var elemIndex = function (dictEq) {+ return function (x) {+ return findIndex(function (v) {+ return Data_Eq.eq(dictEq)(v)(x);+ });+ };+};+var dropWhile = function (p) {+ var go = function (__copy_v) {+ var v = __copy_v;+ var __tco_done = false;+ var __tco_result;+ var __tco_v;+ function __tco_loop(v) {+ if (v instanceof Data_List_Types.Cons && p(v.value0)) {+ __tco_v = v.value1;+ return;+ };+ __tco_done = true;+ return v;+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(v);+ v = __tco_v;+ };+ return __tco_result;+ };+ return go;+};+var drop = function (__copy_v) {+ return function (__copy_v1) {+ var v = __copy_v;+ var v1 = __copy_v1;+ var __tco_done = false;+ var __tco_result;+ var __tco_v;+ var __tco_v1;+ function __tco_loop(v, v1) {+ if (v === 0) {+ __tco_done = true;+ return v1;+ };+ if (v1 instanceof Data_List_Types.Nil) {+ __tco_done = true;+ return Data_List_Types.Nil.value;+ };+ if (v1 instanceof Data_List_Types.Cons) {+ __tco_v = v - 1 | 0;+ __tco_v1 = v1.value1;+ return;+ };+ throw new Error("Failed pattern match at Data.List line 505, column 1 - line 505, column 15: " + [ v.constructor.name, v1.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(v, v1);+ v = __tco_v;+ v1 = __tco_v1;+ };+ return __tco_result;+ };+};+var slice = function (start) {+ return function (end) {+ return function (xs) {+ return take(end - start | 0)(drop(start)(xs));+ };+ };+};+var deleteBy = function (v) {+ return function (v1) {+ return function (v2) {+ if (v2 instanceof Data_List_Types.Nil) {+ return Data_List_Types.Nil.value;+ };+ if (v2 instanceof Data_List_Types.Cons && v(v1)(v2.value0)) {+ return v2.value1;+ };+ if (v2 instanceof Data_List_Types.Cons) {+ return new Data_List_Types.Cons(v2.value0, deleteBy(v)(v1)(v2.value1));+ };+ throw new Error("Failed pattern match at Data.List line 606, column 1 - line 606, column 23: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);+ };+ };+};+var unionBy = function (eq) {+ return function (xs) {+ return function (ys) {+ return Data_Semigroup.append(Data_List_Types.semigroupList)(xs)(Data_Foldable.foldl(Data_List_Types.foldableList)(Data_Function.flip(deleteBy(eq)))(nubBy(eq)(ys))(xs));+ };+ };+};+var union = function (dictEq) {+ return unionBy(Data_Eq.eq(dictEq));+};+var deleteAt = function (v) {+ return function (v1) {+ if (v === 0 && v1 instanceof Data_List_Types.Cons) {+ return new Data_Maybe.Just(v1.value1);+ };+ if (v1 instanceof Data_List_Types.Cons) {+ return Data_Functor.map(Data_Maybe.functorMaybe)(function (v2) {+ return new Data_List_Types.Cons(v1.value0, v2);+ })(deleteAt(v - 1 | 0)(v1.value1));+ };+ return Data_Maybe.Nothing.value;+ };+};+var $$delete = function (dictEq) {+ return deleteBy(Data_Eq.eq(dictEq));+};+var difference = function (dictEq) {+ return Data_Foldable.foldl(Data_List_Types.foldableList)(Data_Function.flip($$delete(dictEq)));+};+var concatMap = Data_Function.flip(Control_Bind.bind(Data_List_Types.bindList));+var concat = function (v) {+ return Control_Bind.bind(Data_List_Types.bindList)(v)(Control_Category.id(Control_Category.categoryFn));+};+var catMaybes = mapMaybe(Control_Category.id(Control_Category.categoryFn));+var alterAt = function (v) {+ return function (v1) {+ return function (v2) {+ if (v === 0 && v2 instanceof Data_List_Types.Cons) {+ return Data_Maybe.Just.create((function () {+ var v3 = v1(v2.value0);+ if (v3 instanceof Data_Maybe.Nothing) {+ return v2.value1;+ };+ if (v3 instanceof Data_Maybe.Just) {+ return new Data_List_Types.Cons(v3.value0, v2.value1);+ };+ throw new Error("Failed pattern match at Data.List line 345, column 3 - line 347, column 23: " + [ v3.constructor.name ]);+ })());+ };+ if (v2 instanceof Data_List_Types.Cons) {+ return Data_Functor.map(Data_Maybe.functorMaybe)(function (v3) {+ return new Data_List_Types.Cons(v2.value0, v3);+ })(alterAt(v - 1 | 0)(v1)(v2.value1));+ };+ return Data_Maybe.Nothing.value;+ };+ };+};+var modifyAt = function (n) {+ return function (f) {+ return alterAt(n)(function ($306) {+ return Data_Maybe.Just.create(f($306));+ });+ };+};+module.exports = {+ alterAt: alterAt, + catMaybes: catMaybes, + concat: concat, + concatMap: concatMap, + "delete": $$delete, + deleteAt: deleteAt, + deleteBy: deleteBy, + difference: difference, + drop: drop, + dropWhile: dropWhile, + elemIndex: elemIndex, + elemLastIndex: elemLastIndex, + filter: filter, + filterM: filterM, + findIndex: findIndex, + findLastIndex: findLastIndex, + foldM: foldM, + fromFoldable: fromFoldable, + group: group, + "group'": group$prime, + groupBy: groupBy, + head: head, + index: index, + init: init, + insert: insert, + insertAt: insertAt, + insertBy: insertBy, + intersect: intersect, + intersectBy: intersectBy, + last: last, + length: length, + many: many, + manyRec: manyRec, + mapMaybe: mapMaybe, + mapWithIndex: mapWithIndex, + modifyAt: modifyAt, + nub: nub, + nubBy: nubBy, + "null": $$null, + range: range, + reverse: reverse, + singleton: singleton, + slice: slice, + snoc: snoc, + some: some, + someRec: someRec, + sort: sort, + sortBy: sortBy, + span: span, + tail: tail, + take: take, + takeWhile: takeWhile, + toUnfoldable: toUnfoldable, + transpose: transpose, + uncons: uncons, + union: union, + unionBy: unionBy, + unsnoc: unsnoc, + unzip: unzip, + updateAt: updateAt, + zip: zip, + zipWith: zipWith, + zipWithA: zipWithA+};++},{"../Control.Alt":38,"../Control.Alternative":39,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Category":47,"../Control.Lazy":50,"../Control.Monad.Rec.Class":77,"../Control.Semigroupoid":92,"../Data.Bifunctor":127,"../Data.Boolean":129,"../Data.Eq":138,"../Data.Foldable":143,"../Data.Function":149,"../Data.Functor":155,"../Data.HeytingAlgebra":160,"../Data.List.Types":193,"../Data.Maybe":198,"../Data.NonEmpty":210,"../Data.Ord":216,"../Data.Ordering":217,"../Data.Ring":227,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Traversable":244,"../Data.Tuple":245,"../Data.Unfoldable":247,"../Data.Unit":249,"../Prelude":268}],195:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Category = require("../Control.Category");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Eq = require("../Data.Eq");+var Data_Foldable = require("../Data.Foldable");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_List = require("../Data.List");+var Data_List_Types = require("../Data.List.Types");+var Data_Maybe = require("../Data.Maybe");+var Data_Monoid = require("../Data.Monoid");+var Data_Ord = require("../Data.Ord");+var Data_Ordering = require("../Data.Ordering");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Show = require("../Data.Show");+var Data_Traversable = require("../Data.Traversable");+var Data_Tuple = require("../Data.Tuple");+var Data_Unfoldable = require("../Data.Unfoldable");+var Partial_Unsafe = require("../Partial.Unsafe");+var Prelude = require("../Prelude");+var Leaf = (function () {+ function Leaf() {++ };+ Leaf.value = new Leaf();+ return Leaf;+})();+var Two = (function () {+ function Two(value0, value1, value2, value3) {+ this.value0 = value0;+ this.value1 = value1;+ this.value2 = value2;+ this.value3 = value3;+ };+ Two.create = function (value0) {+ return function (value1) {+ return function (value2) {+ return function (value3) {+ return new Two(value0, value1, value2, value3);+ };+ };+ };+ };+ return Two;+})();+var Three = (function () {+ function Three(value0, value1, value2, value3, value4, value5, value6) {+ this.value0 = value0;+ this.value1 = value1;+ this.value2 = value2;+ this.value3 = value3;+ this.value4 = value4;+ this.value5 = value5;+ this.value6 = value6;+ };+ Three.create = function (value0) {+ return function (value1) {+ return function (value2) {+ return function (value3) {+ return function (value4) {+ return function (value5) {+ return function (value6) {+ return new Three(value0, value1, value2, value3, value4, value5, value6);+ };+ };+ };+ };+ };+ };+ };+ return Three;+})();+var TwoLeft = (function () {+ function TwoLeft(value0, value1, value2) {+ this.value0 = value0;+ this.value1 = value1;+ this.value2 = value2;+ };+ TwoLeft.create = function (value0) {+ return function (value1) {+ return function (value2) {+ return new TwoLeft(value0, value1, value2);+ };+ };+ };+ return TwoLeft;+})();+var TwoRight = (function () {+ function TwoRight(value0, value1, value2) {+ this.value0 = value0;+ this.value1 = value1;+ this.value2 = value2;+ };+ TwoRight.create = function (value0) {+ return function (value1) {+ return function (value2) {+ return new TwoRight(value0, value1, value2);+ };+ };+ };+ return TwoRight;+})();+var ThreeLeft = (function () {+ function ThreeLeft(value0, value1, value2, value3, value4, value5) {+ this.value0 = value0;+ this.value1 = value1;+ this.value2 = value2;+ this.value3 = value3;+ this.value4 = value4;+ this.value5 = value5;+ };+ ThreeLeft.create = function (value0) {+ return function (value1) {+ return function (value2) {+ return function (value3) {+ return function (value4) {+ return function (value5) {+ return new ThreeLeft(value0, value1, value2, value3, value4, value5);+ };+ };+ };+ };+ };+ };+ return ThreeLeft;+})();+var ThreeMiddle = (function () {+ function ThreeMiddle(value0, value1, value2, value3, value4, value5) {+ this.value0 = value0;+ this.value1 = value1;+ this.value2 = value2;+ this.value3 = value3;+ this.value4 = value4;+ this.value5 = value5;+ };+ ThreeMiddle.create = function (value0) {+ return function (value1) {+ return function (value2) {+ return function (value3) {+ return function (value4) {+ return function (value5) {+ return new ThreeMiddle(value0, value1, value2, value3, value4, value5);+ };+ };+ };+ };+ };+ };+ return ThreeMiddle;+})();+var ThreeRight = (function () {+ function ThreeRight(value0, value1, value2, value3, value4, value5) {+ this.value0 = value0;+ this.value1 = value1;+ this.value2 = value2;+ this.value3 = value3;+ this.value4 = value4;+ this.value5 = value5;+ };+ ThreeRight.create = function (value0) {+ return function (value1) {+ return function (value2) {+ return function (value3) {+ return function (value4) {+ return function (value5) {+ return new ThreeRight(value0, value1, value2, value3, value4, value5);+ };+ };+ };+ };+ };+ };+ return ThreeRight;+})();+var KickUp = (function () {+ function KickUp(value0, value1, value2, value3) {+ this.value0 = value0;+ this.value1 = value1;+ this.value2 = value2;+ this.value3 = value3;+ };+ KickUp.create = function (value0) {+ return function (value1) {+ return function (value2) {+ return function (value3) {+ return new KickUp(value0, value1, value2, value3);+ };+ };+ };+ };+ return KickUp;+})();+var values = function (v) {+ if (v instanceof Leaf) {+ return Data_List_Types.Nil.value;+ };+ if (v instanceof Two) {+ return Data_Semigroup.append(Data_List_Types.semigroupList)(values(v.value0))(Data_Semigroup.append(Data_List_Types.semigroupList)(Control_Applicative.pure(Data_List_Types.applicativeList)(v.value2))(values(v.value3)));+ };+ if (v instanceof Three) {+ return Data_Semigroup.append(Data_List_Types.semigroupList)(values(v.value0))(Data_Semigroup.append(Data_List_Types.semigroupList)(Control_Applicative.pure(Data_List_Types.applicativeList)(v.value2))(Data_Semigroup.append(Data_List_Types.semigroupList)(values(v.value3))(Data_Semigroup.append(Data_List_Types.semigroupList)(Control_Applicative.pure(Data_List_Types.applicativeList)(v.value5))(values(v.value6)))));+ };+ throw new Error("Failed pattern match at Data.Map line 425, column 1 - line 425, column 18: " + [ v.constructor.name ]);+};+var size = function ($673) {+ return Data_List.length(values($673));+};+var singleton = function (k) {+ return function (v) {+ return new Two(Leaf.value, k, v, Leaf.value);+ };+};+var toAscUnfoldable = function (dictUnfoldable) {+ return function (m) {+ var go = function (__copy_v) {+ var v = __copy_v;+ var __tco_done = false;+ var __tco_result;+ var __tco_v;+ function __tco_loop(v) {+ if (v instanceof Data_List_Types.Nil) {+ __tco_done = true;+ return Data_Maybe.Nothing.value;+ };+ if (v instanceof Data_List_Types.Cons) {+ if (v.value0 instanceof Leaf) {+ __tco_v = v.value1;+ return;+ };+ if (v.value0 instanceof Two && (v.value0.value0 instanceof Leaf && v.value0.value3 instanceof Leaf)) {+ __tco_done = true;+ return Data_Maybe.Just.create(new Data_Tuple.Tuple(new Data_Tuple.Tuple(v.value0.value1, v.value0.value2), v.value1));+ };+ if (v.value0 instanceof Two && v.value0.value0 instanceof Leaf) {+ __tco_done = true;+ return Data_Maybe.Just.create(new Data_Tuple.Tuple(new Data_Tuple.Tuple(v.value0.value1, v.value0.value2), new Data_List_Types.Cons(v.value0.value3, v.value1)));+ };+ if (v.value0 instanceof Two) {+ __tco_v = new Data_List_Types.Cons(v.value0.value0, new Data_List_Types.Cons(singleton(v.value0.value1)(v.value0.value2), new Data_List_Types.Cons(v.value0.value3, v.value1)));+ return;+ };+ if (v.value0 instanceof Three) {+ __tco_v = new Data_List_Types.Cons(v.value0.value0, new Data_List_Types.Cons(singleton(v.value0.value1)(v.value0.value2), new Data_List_Types.Cons(v.value0.value3, new Data_List_Types.Cons(singleton(v.value0.value4)(v.value0.value5), new Data_List_Types.Cons(v.value0.value6, v.value1)))));+ return;+ };+ throw new Error("Failed pattern match at Data.Map line 406, column 18 - line 415, column 71: " + [ v.value0.constructor.name ]);+ };+ throw new Error("Failed pattern match at Data.Map line 404, column 21 - line 415, column 71: " + [ v.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(v);+ v = __tco_v;+ };+ return __tco_result;+ };+ return Data_Unfoldable.unfoldr(dictUnfoldable)(go)(new Data_List_Types.Cons(m, Data_List_Types.Nil.value));+ };+};+var toAscArray = toAscUnfoldable(Data_Unfoldable.unfoldableArray);+var toUnfoldable = function (dictUnfoldable) {+ return function (m) {+ var go = function (__copy_v) {+ var v = __copy_v;+ var __tco_done = false;+ var __tco_result;+ var __tco_v;+ function __tco_loop(v) {+ if (v instanceof Data_List_Types.Nil) {+ __tco_done = true;+ return Data_Maybe.Nothing.value;+ };+ if (v instanceof Data_List_Types.Cons) {+ if (v.value0 instanceof Leaf) {+ __tco_v = v.value1;+ return;+ };+ if (v.value0 instanceof Two) {+ __tco_done = true;+ return Data_Maybe.Just.create(new Data_Tuple.Tuple(new Data_Tuple.Tuple(v.value0.value1, v.value0.value2), new Data_List_Types.Cons(v.value0.value0, new Data_List_Types.Cons(v.value0.value3, v.value1))));+ };+ if (v.value0 instanceof Three) {+ __tco_done = true;+ return Data_Maybe.Just.create(new Data_Tuple.Tuple(new Data_Tuple.Tuple(v.value0.value1, v.value0.value2), new Data_List_Types.Cons(singleton(v.value0.value4)(v.value0.value5), new Data_List_Types.Cons(v.value0.value0, new Data_List_Types.Cons(v.value0.value3, new Data_List_Types.Cons(v.value0.value6, v.value1))))));+ };+ throw new Error("Failed pattern match at Data.Map line 395, column 18 - line 400, column 77: " + [ v.value0.constructor.name ]);+ };+ throw new Error("Failed pattern match at Data.Map line 393, column 18 - line 400, column 77: " + [ v.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(v);+ v = __tco_v;+ };+ return __tco_result;+ };+ return Data_Unfoldable.unfoldr(dictUnfoldable)(go)(new Data_List_Types.Cons(m, Data_List_Types.Nil.value));+ };+};+var showTree = function (dictShow) {+ return function (dictShow1) {+ return function (v) {+ if (v instanceof Leaf) {+ return "Leaf";+ };+ if (v instanceof Two) {+ return "Two (" + (showTree(dictShow)(dictShow1)(v.value0) + (") (" + (Data_Show.show(dictShow)(v.value1) + (") (" + (Data_Show.show(dictShow1)(v.value2) + (") (" + (showTree(dictShow)(dictShow1)(v.value3) + ")")))))));+ };+ if (v instanceof Three) {+ return "Three (" + (showTree(dictShow)(dictShow1)(v.value0) + (") (" + (Data_Show.show(dictShow)(v.value1) + (") (" + (Data_Show.show(dictShow1)(v.value2) + (") (" + (showTree(dictShow)(dictShow1)(v.value3) + (") (" + (Data_Show.show(dictShow)(v.value4) + (") (" + (Data_Show.show(dictShow1)(v.value5) + (") (" + (showTree(dictShow)(dictShow1)(v.value6) + ")")))))))))))));+ };+ throw new Error("Failed pattern match at Data.Map line 109, column 1 - line 110, column 1: " + [ v.constructor.name ]);+ };+ };+};+var showMap = function (dictShow) {+ return function (dictShow1) {+ return new Data_Show.Show(function (m) {+ return "(fromFoldable " + (Data_Show.show(Data_Show.showArray(Data_Tuple.showTuple(dictShow)(dictShow1)))(toAscArray(m)) + ")");+ });+ };+};+var mapWithKey = function (v) {+ return function (v1) {+ if (v1 instanceof Leaf) {+ return Leaf.value;+ };+ if (v1 instanceof Two) {+ return new Two(mapWithKey(v)(v1.value0), v1.value1, v(v1.value1)(v1.value2), mapWithKey(v)(v1.value3));+ };+ if (v1 instanceof Three) {+ return new Three(mapWithKey(v)(v1.value0), v1.value1, v(v1.value1)(v1.value2), mapWithKey(v)(v1.value3), v1.value4, v(v1.value4)(v1.value5), mapWithKey(v)(v1.value6));+ };+ throw new Error("Failed pattern match at Data.Map line 451, column 1 - line 451, column 25: " + [ v.constructor.name, v1.constructor.name ]);+ };+};+var lookupLE = function (dictOrd) {+ return function (v) {+ return function (v1) {+ if (v1 instanceof Leaf) {+ return Data_Maybe.Nothing.value;+ };+ if (v1 instanceof Two) {+ var v2 = Data_Ord.compare(dictOrd)(v)(v1.value1);+ if (v2 instanceof Data_Ordering.EQ) {+ return new Data_Maybe.Just({+ key: v1.value1, + value: v1.value2+ });+ };+ if (v2 instanceof Data_Ordering.GT) {+ return Data_Maybe.Just.create(Data_Maybe.fromMaybe({+ key: v1.value1, + value: v1.value2+ })(lookupLE(dictOrd)(v)(v1.value3)));+ };+ if (v2 instanceof Data_Ordering.LT) {+ return lookupLE(dictOrd)(v)(v1.value0);+ };+ throw new Error("Failed pattern match at Data.Map line 176, column 37 - line 179, column 24: " + [ v2.constructor.name ]);+ };+ if (v1 instanceof Three) {+ var v3 = Data_Ord.compare(dictOrd)(v)(v1.value4);+ if (v3 instanceof Data_Ordering.EQ) {+ return new Data_Maybe.Just({+ key: v1.value4, + value: v1.value5+ });+ };+ if (v3 instanceof Data_Ordering.GT) {+ return Data_Maybe.Just.create(Data_Maybe.fromMaybe({+ key: v1.value4, + value: v1.value5+ })(lookupLE(dictOrd)(v)(v1.value6)));+ };+ if (v3 instanceof Data_Ordering.LT) {+ return lookupLE(dictOrd)(v)(new Two(v1.value0, v1.value1, v1.value2, v1.value3));+ };+ throw new Error("Failed pattern match at Data.Map line 180, column 49 - line 183, column 40: " + [ v3.constructor.name ]);+ };+ throw new Error("Failed pattern match at Data.Map line 175, column 1 - line 175, column 26: " + [ v.constructor.name, v1.constructor.name ]);+ };+ };+};+var lookupGE = function (dictOrd) {+ return function (v) {+ return function (v1) {+ if (v1 instanceof Leaf) {+ return Data_Maybe.Nothing.value;+ };+ if (v1 instanceof Two) {+ var v2 = Data_Ord.compare(dictOrd)(v)(v1.value1);+ if (v2 instanceof Data_Ordering.EQ) {+ return new Data_Maybe.Just({+ key: v1.value1, + value: v1.value2+ });+ };+ if (v2 instanceof Data_Ordering.LT) {+ return Data_Maybe.Just.create(Data_Maybe.fromMaybe({+ key: v1.value1, + value: v1.value2+ })(lookupGE(dictOrd)(v)(v1.value0)));+ };+ if (v2 instanceof Data_Ordering.GT) {+ return lookupGE(dictOrd)(v)(v1.value3);+ };+ throw new Error("Failed pattern match at Data.Map line 200, column 37 - line 203, column 25: " + [ v2.constructor.name ]);+ };+ if (v1 instanceof Three) {+ var v3 = Data_Ord.compare(dictOrd)(v)(v1.value1);+ if (v3 instanceof Data_Ordering.EQ) {+ return new Data_Maybe.Just({+ key: v1.value1, + value: v1.value2+ });+ };+ if (v3 instanceof Data_Ordering.LT) {+ return Data_Maybe.Just.create(Data_Maybe.fromMaybe({+ key: v1.value1, + value: v1.value2+ })(lookupGE(dictOrd)(v)(v1.value0)));+ };+ if (v3 instanceof Data_Ordering.GT) {+ return lookupGE(dictOrd)(v)(new Two(v1.value3, v1.value4, v1.value5, v1.value6));+ };+ throw new Error("Failed pattern match at Data.Map line 204, column 49 - line 207, column 41: " + [ v3.constructor.name ]);+ };+ throw new Error("Failed pattern match at Data.Map line 199, column 1 - line 199, column 26: " + [ v.constructor.name, v1.constructor.name ]);+ };+ };+};+var lookup = function (dictOrd) {+ return function (k) {+ return function (tree) {+ if (tree instanceof Leaf) {+ return Data_Maybe.Nothing.value;+ };+ var comp = Data_Ord.compare(dictOrd);+ var __unused = function (dictPartial1) {+ return function ($dollar45) {+ return $dollar45;+ };+ };+ return __unused()((function () {+ if (tree instanceof Two) {+ var v1 = comp(k)(tree.value1);+ if (v1 instanceof Data_Ordering.EQ) {+ return new Data_Maybe.Just(tree.value2);+ };+ if (v1 instanceof Data_Ordering.LT) {+ return lookup(dictOrd)(k)(tree.value0);+ };+ return lookup(dictOrd)(k)(tree.value3);+ };+ if (tree instanceof Three) {+ var v = comp(k)(tree.value1);+ if (v instanceof Data_Ordering.EQ) {+ return new Data_Maybe.Just(tree.value2);+ };+ var v3 = comp(k)(tree.value4);+ if (v3 instanceof Data_Ordering.EQ) {+ return new Data_Maybe.Just(tree.value5);+ };+ if (v instanceof Data_Ordering.LT) {+ return lookup(dictOrd)(k)(tree.value0);+ };+ if (v3 instanceof Data_Ordering.GT) {+ return lookup(dictOrd)(k)(tree.value6);+ };+ return lookup(dictOrd)(k)(tree.value3);+ };+ throw new Error("Failed pattern match at Data.Map line 156, column 10 - line 170, column 39: " + [ tree.constructor.name ]);+ })());+ };+ };+};+var member = function (dictOrd) {+ return function (k) {+ return function (m) {+ return Data_Maybe.isJust(lookup(dictOrd)(k)(m));+ };+ };+};+var keys = function (v) {+ if (v instanceof Leaf) {+ return Data_List_Types.Nil.value;+ };+ if (v instanceof Two) {+ return Data_Semigroup.append(Data_List_Types.semigroupList)(keys(v.value0))(Data_Semigroup.append(Data_List_Types.semigroupList)(Control_Applicative.pure(Data_List_Types.applicativeList)(v.value1))(keys(v.value3)));+ };+ if (v instanceof Three) {+ return Data_Semigroup.append(Data_List_Types.semigroupList)(keys(v.value0))(Data_Semigroup.append(Data_List_Types.semigroupList)(Control_Applicative.pure(Data_List_Types.applicativeList)(v.value1))(Data_Semigroup.append(Data_List_Types.semigroupList)(keys(v.value3))(Data_Semigroup.append(Data_List_Types.semigroupList)(Control_Applicative.pure(Data_List_Types.applicativeList)(v.value4))(keys(v.value6)))));+ };+ throw new Error("Failed pattern match at Data.Map line 419, column 1 - line 419, column 16: " + [ v.constructor.name ]);+};+var isEmpty = function (v) {+ if (v instanceof Leaf) {+ return true;+ };+ return false;+};+var functorMap = new Data_Functor.Functor(function (v) {+ return function (v1) {+ if (v1 instanceof Leaf) {+ return Leaf.value;+ };+ if (v1 instanceof Two) {+ return new Two(Data_Functor.map(functorMap)(v)(v1.value0), v1.value1, v(v1.value2), Data_Functor.map(functorMap)(v)(v1.value3));+ };+ if (v1 instanceof Three) {+ return new Three(Data_Functor.map(functorMap)(v)(v1.value0), v1.value1, v(v1.value2), Data_Functor.map(functorMap)(v)(v1.value3), v1.value4, v(v1.value5), Data_Functor.map(functorMap)(v)(v1.value6));+ };+ throw new Error("Failed pattern match at Data.Map line 81, column 3 - line 81, column 20: " + [ v.constructor.name, v1.constructor.name ]);+ };+});+var fromZipper = function (__copy_dictOrd) {+ return function (__copy_v) {+ return function (__copy_tree) {+ var dictOrd = __copy_dictOrd;+ var v = __copy_v;+ var tree = __copy_tree;+ var __tco_done = false;+ var __tco_result;+ var __tco_dictOrd;+ var __tco_v;+ var __tco_tree;+ function __tco_loop(dictOrd, v, tree) {+ if (v instanceof Data_List_Types.Nil) {+ __tco_done = true;+ return tree;+ };+ if (v instanceof Data_List_Types.Cons) {+ if (v.value0 instanceof TwoLeft) {+ __tco_dictOrd = dictOrd;+ __tco_v = v.value1;+ __tco_tree = new Two(tree, v.value0.value0, v.value0.value1, v.value0.value2);+ return;+ };+ if (v.value0 instanceof TwoRight) {+ __tco_dictOrd = dictOrd;+ __tco_v = v.value1;+ __tco_tree = new Two(v.value0.value0, v.value0.value1, v.value0.value2, tree);+ return;+ };+ if (v.value0 instanceof ThreeLeft) {+ __tco_dictOrd = dictOrd;+ __tco_v = v.value1;+ __tco_tree = new Three(tree, v.value0.value0, v.value0.value1, v.value0.value2, v.value0.value3, v.value0.value4, v.value0.value5);+ return;+ };+ if (v.value0 instanceof ThreeMiddle) {+ __tco_dictOrd = dictOrd;+ __tco_v = v.value1;+ __tco_tree = new Three(v.value0.value0, v.value0.value1, v.value0.value2, tree, v.value0.value3, v.value0.value4, v.value0.value5);+ return;+ };+ if (v.value0 instanceof ThreeRight) {+ __tco_dictOrd = dictOrd;+ __tco_v = v.value1;+ __tco_tree = new Three(v.value0.value0, v.value0.value1, v.value0.value2, v.value0.value3, v.value0.value4, v.value0.value5, tree);+ return;+ };+ throw new Error("Failed pattern match at Data.Map line 247, column 3 - line 252, column 88: " + [ v.value0.constructor.name ]);+ };+ throw new Error("Failed pattern match at Data.Map line 245, column 1 - line 245, column 27: " + [ v.constructor.name, tree.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(dictOrd, v, tree);+ dictOrd = __tco_dictOrd;+ v = __tco_v;+ tree = __tco_tree;+ };+ return __tco_result;+ };+ };+};+var insert = function (dictOrd) {+ var up = function (__copy_v) {+ return function (__copy_v1) {+ var v = __copy_v;+ var v1 = __copy_v1;+ var __tco_done = false;+ var __tco_result;+ var __tco_v;+ var __tco_v1;+ function __tco_loop(v, v1) {+ if (v instanceof Data_List_Types.Nil) {+ __tco_done = true;+ return new Two(v1.value0, v1.value1, v1.value2, v1.value3);+ };+ if (v instanceof Data_List_Types.Cons) {+ if (v.value0 instanceof TwoLeft) {+ __tco_done = true;+ return fromZipper(dictOrd)(v.value1)(new Three(v1.value0, v1.value1, v1.value2, v1.value3, v.value0.value0, v.value0.value1, v.value0.value2));+ };+ if (v.value0 instanceof TwoRight) {+ __tco_done = true;+ return fromZipper(dictOrd)(v.value1)(new Three(v.value0.value0, v.value0.value1, v.value0.value2, v1.value0, v1.value1, v1.value2, v1.value3));+ };+ if (v.value0 instanceof ThreeLeft) {+ __tco_v = v.value1;+ __tco_v1 = new KickUp(new Two(v1.value0, v1.value1, v1.value2, v1.value3), v.value0.value0, v.value0.value1, new Two(v.value0.value2, v.value0.value3, v.value0.value4, v.value0.value5));+ return;+ };+ if (v.value0 instanceof ThreeMiddle) {+ __tco_v = v.value1;+ __tco_v1 = new KickUp(new Two(v.value0.value0, v.value0.value1, v.value0.value2, v1.value0), v1.value1, v1.value2, new Two(v1.value3, v.value0.value3, v.value0.value4, v.value0.value5));+ return;+ };+ if (v.value0 instanceof ThreeRight) {+ __tco_v = v.value1;+ __tco_v1 = new KickUp(new Two(v.value0.value0, v.value0.value1, v.value0.value2, v.value0.value3), v.value0.value4, v.value0.value5, new Two(v1.value0, v1.value1, v1.value2, v1.value3));+ return;+ };+ throw new Error("Failed pattern match at Data.Map line 283, column 5 - line 288, column 104: " + [ v.value0.constructor.name, v1.constructor.name ]);+ };+ throw new Error("Failed pattern match at Data.Map line 281, column 3 - line 281, column 54: " + [ v.constructor.name, v1.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(v, v1);+ v = __tco_v;+ v1 = __tco_v1;+ };+ return __tco_result;+ };+ };+ var comp = Data_Ord.compare(dictOrd);+ var down = function (__copy_ctx) {+ return function (__copy_k) {+ return function (__copy_v) {+ return function (__copy_v1) {+ var ctx = __copy_ctx;+ var k = __copy_k;+ var v = __copy_v;+ var v1 = __copy_v1;+ var __tco_done = false;+ var __tco_result;+ var __tco_ctx;+ var __tco_k;+ var __tco_v;+ var __tco_v1;+ function __tco_loop(ctx, k, v, v1) {+ if (v1 instanceof Leaf) {+ __tco_done = true;+ return up(ctx)(new KickUp(Leaf.value, k, v, Leaf.value));+ };+ if (v1 instanceof Two) {+ var v3 = comp(k)(v1.value1);+ if (v3 instanceof Data_Ordering.EQ) {+ __tco_done = true;+ return fromZipper(dictOrd)(ctx)(new Two(v1.value0, k, v, v1.value3));+ };+ if (v3 instanceof Data_Ordering.LT) {+ __tco_ctx = new Data_List_Types.Cons(new TwoLeft(v1.value1, v1.value2, v1.value3), ctx);+ __tco_k = k;+ __tco_v = v;+ __tco_v1 = v1.value0;+ return;+ };+ __tco_ctx = new Data_List_Types.Cons(new TwoRight(v1.value0, v1.value1, v1.value2), ctx);+ __tco_k = k;+ __tco_v = v;+ __tco_v1 = v1.value3;+ return;+ };+ if (v1 instanceof Three) {+ var v3 = comp(k)(v1.value1);+ if (v3 instanceof Data_Ordering.EQ) {+ __tco_done = true;+ return fromZipper(dictOrd)(ctx)(new Three(v1.value0, k, v, v1.value3, v1.value4, v1.value5, v1.value6));+ };+ var v4 = comp(k)(v1.value4);+ if (v4 instanceof Data_Ordering.EQ) {+ __tco_done = true;+ return fromZipper(dictOrd)(ctx)(new Three(v1.value0, v1.value1, v1.value2, v1.value3, k, v, v1.value6));+ };+ if (v3 instanceof Data_Ordering.LT) {+ __tco_ctx = new Data_List_Types.Cons(new ThreeLeft(v1.value1, v1.value2, v1.value3, v1.value4, v1.value5, v1.value6), ctx);+ __tco_k = k;+ __tco_v = v;+ __tco_v1 = v1.value0;+ return;+ };+ if (v3 instanceof Data_Ordering.GT && v4 instanceof Data_Ordering.LT) {+ __tco_ctx = new Data_List_Types.Cons(new ThreeMiddle(v1.value0, v1.value1, v1.value2, v1.value4, v1.value5, v1.value6), ctx);+ __tco_k = k;+ __tco_v = v;+ __tco_v1 = v1.value3;+ return;+ };+ __tco_ctx = new Data_List_Types.Cons(new ThreeRight(v1.value0, v1.value1, v1.value2, v1.value3, v1.value4, v1.value5), ctx);+ __tco_k = k;+ __tco_v = v;+ __tco_v1 = v1.value6;+ return;+ };+ throw new Error("Failed pattern match at Data.Map line 264, column 3 - line 264, column 52: " + [ ctx.constructor.name, k.constructor.name, v.constructor.name, v1.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(ctx, k, v, v1);+ ctx = __tco_ctx;+ k = __tco_k;+ v = __tco_v;+ v1 = __tco_v1;+ };+ return __tco_result;+ };+ };+ };+ };+ return down(Data_List_Types.Nil.value);+};+var pop = function (dictOrd) {+ var up = function (ctxs) {+ return function (tree) {+ if (ctxs instanceof Data_List_Types.Nil) {+ return tree;+ };+ if (ctxs instanceof Data_List_Types.Cons) {+ var __unused = function (dictPartial1) {+ return function ($dollar53) {+ return $dollar53;+ };+ };+ return __unused()((function () {+ if (ctxs.value0 instanceof TwoLeft && (ctxs.value0.value2 instanceof Leaf && tree instanceof Leaf)) {+ return fromZipper(dictOrd)(ctxs.value1)(new Two(Leaf.value, ctxs.value0.value0, ctxs.value0.value1, Leaf.value));+ };+ if (ctxs.value0 instanceof TwoRight && (ctxs.value0.value0 instanceof Leaf && tree instanceof Leaf)) {+ return fromZipper(dictOrd)(ctxs.value1)(new Two(Leaf.value, ctxs.value0.value1, ctxs.value0.value2, Leaf.value));+ };+ if (ctxs.value0 instanceof TwoLeft && ctxs.value0.value2 instanceof Two) {+ return up(ctxs.value1)(new Three(tree, ctxs.value0.value0, ctxs.value0.value1, ctxs.value0.value2.value0, ctxs.value0.value2.value1, ctxs.value0.value2.value2, ctxs.value0.value2.value3));+ };+ if (ctxs.value0 instanceof TwoRight && ctxs.value0.value0 instanceof Two) {+ return up(ctxs.value1)(new Three(ctxs.value0.value0.value0, ctxs.value0.value0.value1, ctxs.value0.value0.value2, ctxs.value0.value0.value3, ctxs.value0.value1, ctxs.value0.value2, tree));+ };+ if (ctxs.value0 instanceof TwoLeft && ctxs.value0.value2 instanceof Three) {+ return fromZipper(dictOrd)(ctxs.value1)(new Two(new Two(tree, ctxs.value0.value0, ctxs.value0.value1, ctxs.value0.value2.value0), ctxs.value0.value2.value1, ctxs.value0.value2.value2, new Two(ctxs.value0.value2.value3, ctxs.value0.value2.value4, ctxs.value0.value2.value5, ctxs.value0.value2.value6)));+ };+ if (ctxs.value0 instanceof TwoRight && ctxs.value0.value0 instanceof Three) {+ return fromZipper(dictOrd)(ctxs.value1)(new Two(new Two(ctxs.value0.value0.value0, ctxs.value0.value0.value1, ctxs.value0.value0.value2, ctxs.value0.value0.value3), ctxs.value0.value0.value4, ctxs.value0.value0.value5, new Two(ctxs.value0.value0.value6, ctxs.value0.value1, ctxs.value0.value2, tree)));+ };+ if (ctxs.value0 instanceof ThreeLeft && (ctxs.value0.value2 instanceof Leaf && (ctxs.value0.value5 instanceof Leaf && tree instanceof Leaf))) {+ return fromZipper(dictOrd)(ctxs.value1)(new Three(Leaf.value, ctxs.value0.value0, ctxs.value0.value1, Leaf.value, ctxs.value0.value3, ctxs.value0.value4, Leaf.value));+ };+ if (ctxs.value0 instanceof ThreeMiddle && (ctxs.value0.value0 instanceof Leaf && (ctxs.value0.value5 instanceof Leaf && tree instanceof Leaf))) {+ return fromZipper(dictOrd)(ctxs.value1)(new Three(Leaf.value, ctxs.value0.value1, ctxs.value0.value2, Leaf.value, ctxs.value0.value3, ctxs.value0.value4, Leaf.value));+ };+ if (ctxs.value0 instanceof ThreeRight && (ctxs.value0.value0 instanceof Leaf && (ctxs.value0.value3 instanceof Leaf && tree instanceof Leaf))) {+ return fromZipper(dictOrd)(ctxs.value1)(new Three(Leaf.value, ctxs.value0.value1, ctxs.value0.value2, Leaf.value, ctxs.value0.value4, ctxs.value0.value5, Leaf.value));+ };+ if (ctxs.value0 instanceof ThreeLeft && ctxs.value0.value2 instanceof Two) {+ return fromZipper(dictOrd)(ctxs.value1)(new Two(new Three(tree, ctxs.value0.value0, ctxs.value0.value1, ctxs.value0.value2.value0, ctxs.value0.value2.value1, ctxs.value0.value2.value2, ctxs.value0.value2.value3), ctxs.value0.value3, ctxs.value0.value4, ctxs.value0.value5));+ };+ if (ctxs.value0 instanceof ThreeMiddle && ctxs.value0.value0 instanceof Two) {+ return fromZipper(dictOrd)(ctxs.value1)(new Two(new Three(ctxs.value0.value0.value0, ctxs.value0.value0.value1, ctxs.value0.value0.value2, ctxs.value0.value0.value3, ctxs.value0.value1, ctxs.value0.value2, tree), ctxs.value0.value3, ctxs.value0.value4, ctxs.value0.value5));+ };+ if (ctxs.value0 instanceof ThreeMiddle && ctxs.value0.value5 instanceof Two) {+ return fromZipper(dictOrd)(ctxs.value1)(new Two(ctxs.value0.value0, ctxs.value0.value1, ctxs.value0.value2, new Three(tree, ctxs.value0.value3, ctxs.value0.value4, ctxs.value0.value5.value0, ctxs.value0.value5.value1, ctxs.value0.value5.value2, ctxs.value0.value5.value3)));+ };+ if (ctxs.value0 instanceof ThreeRight && ctxs.value0.value3 instanceof Two) {+ return fromZipper(dictOrd)(ctxs.value1)(new Two(ctxs.value0.value0, ctxs.value0.value1, ctxs.value0.value2, new Three(ctxs.value0.value3.value0, ctxs.value0.value3.value1, ctxs.value0.value3.value2, ctxs.value0.value3.value3, ctxs.value0.value4, ctxs.value0.value5, tree)));+ };+ if (ctxs.value0 instanceof ThreeLeft && ctxs.value0.value2 instanceof Three) {+ return fromZipper(dictOrd)(ctxs.value1)(new Three(new Two(tree, ctxs.value0.value0, ctxs.value0.value1, ctxs.value0.value2.value0), ctxs.value0.value2.value1, ctxs.value0.value2.value2, new Two(ctxs.value0.value2.value3, ctxs.value0.value2.value4, ctxs.value0.value2.value5, ctxs.value0.value2.value6), ctxs.value0.value3, ctxs.value0.value4, ctxs.value0.value5));+ };+ if (ctxs.value0 instanceof ThreeMiddle && ctxs.value0.value0 instanceof Three) {+ return fromZipper(dictOrd)(ctxs.value1)(new Three(new Two(ctxs.value0.value0.value0, ctxs.value0.value0.value1, ctxs.value0.value0.value2, ctxs.value0.value0.value3), ctxs.value0.value0.value4, ctxs.value0.value0.value5, new Two(ctxs.value0.value0.value6, ctxs.value0.value1, ctxs.value0.value2, tree), ctxs.value0.value3, ctxs.value0.value4, ctxs.value0.value5));+ };+ if (ctxs.value0 instanceof ThreeMiddle && ctxs.value0.value5 instanceof Three) {+ return fromZipper(dictOrd)(ctxs.value1)(new Three(ctxs.value0.value0, ctxs.value0.value1, ctxs.value0.value2, new Two(tree, ctxs.value0.value3, ctxs.value0.value4, ctxs.value0.value5.value0), ctxs.value0.value5.value1, ctxs.value0.value5.value2, new Two(ctxs.value0.value5.value3, ctxs.value0.value5.value4, ctxs.value0.value5.value5, ctxs.value0.value5.value6)));+ };+ if (ctxs.value0 instanceof ThreeRight && ctxs.value0.value3 instanceof Three) {+ return fromZipper(dictOrd)(ctxs.value1)(new Three(ctxs.value0.value0, ctxs.value0.value1, ctxs.value0.value2, new Two(ctxs.value0.value3.value0, ctxs.value0.value3.value1, ctxs.value0.value3.value2, ctxs.value0.value3.value3), ctxs.value0.value3.value4, ctxs.value0.value3.value5, new Two(ctxs.value0.value3.value6, ctxs.value0.value4, ctxs.value0.value5, tree)));+ };+ throw new Error("Failed pattern match at Data.Map line 333, column 9 - line 350, column 136: " + [ ctxs.value0.constructor.name, tree.constructor.name ]);+ })());+ };+ throw new Error("Failed pattern match at Data.Map line 330, column 5 - line 350, column 136: " + [ ctxs.constructor.name ]);+ };+ };+ var removeMaxNode = function (ctx) {+ return function (m) {+ var __unused = function (dictPartial1) {+ return function ($dollar55) {+ return $dollar55;+ };+ };+ return __unused()((function () {+ if (m instanceof Two && (m.value0 instanceof Leaf && m.value3 instanceof Leaf)) {+ return up(ctx)(Leaf.value);+ };+ if (m instanceof Two) {+ return removeMaxNode(new Data_List_Types.Cons(new TwoRight(m.value0, m.value1, m.value2), ctx))(m.value3);+ };+ if (m instanceof Three && (m.value0 instanceof Leaf && (m.value3 instanceof Leaf && m.value6 instanceof Leaf))) {+ return up(new Data_List_Types.Cons(new TwoRight(Leaf.value, m.value1, m.value2), ctx))(Leaf.value);+ };+ if (m instanceof Three) {+ return removeMaxNode(new Data_List_Types.Cons(new ThreeRight(m.value0, m.value1, m.value2, m.value3, m.value4, m.value5), ctx))(m.value6);+ };+ throw new Error("Failed pattern match at Data.Map line 362, column 5 - line 366, column 107: " + [ m.constructor.name ]);+ })());+ };+ };+ var maxNode = function (m) {+ var __unused = function (dictPartial1) {+ return function ($dollar57) {+ return $dollar57;+ };+ };+ return __unused()((function () {+ if (m instanceof Two && m.value3 instanceof Leaf) {+ return {+ key: m.value1, + value: m.value2+ };+ };+ if (m instanceof Two) {+ return maxNode(m.value3);+ };+ if (m instanceof Three && m.value6 instanceof Leaf) {+ return {+ key: m.value4, + value: m.value5+ };+ };+ if (m instanceof Three) {+ return maxNode(m.value6);+ };+ throw new Error("Failed pattern match at Data.Map line 353, column 33 - line 357, column 45: " + [ m.constructor.name ]);+ })());+ };+ var comp = Data_Ord.compare(dictOrd);+ var down = function (__copy_ctx) {+ return function (__copy_k) {+ return function (__copy_m) {+ var ctx = __copy_ctx;+ var k = __copy_k;+ var m = __copy_m;+ var __tco_done = false;+ var __tco_result;+ var __tco_ctx;+ var __tco_k;+ var __tco_m;+ function __tco_loop(ctx, k, m) {+ if (m instanceof Leaf) {+ __tco_done = true;+ return Data_Maybe.Nothing.value;+ };+ if (m instanceof Two) {+ var v = comp(k)(m.value1);+ if (m.value3 instanceof Leaf && v instanceof Data_Ordering.EQ) {+ __tco_done = true;+ return new Data_Maybe.Just(new Data_Tuple.Tuple(m.value2, up(ctx)(Leaf.value)));+ };+ if (v instanceof Data_Ordering.EQ) {+ var max = maxNode(m.value0);+ __tco_done = true;+ return new Data_Maybe.Just(new Data_Tuple.Tuple(m.value2, removeMaxNode(new Data_List_Types.Cons(new TwoLeft(max.key, max.value, m.value3), ctx))(m.value0)));+ };+ if (v instanceof Data_Ordering.LT) {+ __tco_ctx = new Data_List_Types.Cons(new TwoLeft(m.value1, m.value2, m.value3), ctx);+ __tco_k = k;+ __tco_m = m.value0;+ return;+ };+ __tco_ctx = new Data_List_Types.Cons(new TwoRight(m.value0, m.value1, m.value2), ctx);+ __tco_k = k;+ __tco_m = m.value3;+ return;+ };+ if (m instanceof Three) {+ var leaves = (function () {+ if (m.value0 instanceof Leaf && (m.value3 instanceof Leaf && m.value6 instanceof Leaf)) {+ return true;+ };+ return false;+ })();+ var v = comp(k)(m.value4);+ var v3 = comp(k)(m.value1);+ if (leaves && v3 instanceof Data_Ordering.EQ) {+ __tco_done = true;+ return new Data_Maybe.Just(new Data_Tuple.Tuple(m.value2, fromZipper(dictOrd)(ctx)(new Two(Leaf.value, m.value4, m.value5, Leaf.value))));+ };+ if (leaves && v instanceof Data_Ordering.EQ) {+ __tco_done = true;+ return new Data_Maybe.Just(new Data_Tuple.Tuple(m.value5, fromZipper(dictOrd)(ctx)(new Two(Leaf.value, m.value1, m.value2, Leaf.value))));+ };+ if (v3 instanceof Data_Ordering.EQ) {+ var max = maxNode(m.value0);+ __tco_done = true;+ return new Data_Maybe.Just(new Data_Tuple.Tuple(m.value2, removeMaxNode(new Data_List_Types.Cons(new ThreeLeft(max.key, max.value, m.value3, m.value4, m.value5, m.value6), ctx))(m.value0)));+ };+ if (v instanceof Data_Ordering.EQ) {+ var max = maxNode(m.value3);+ __tco_done = true;+ return new Data_Maybe.Just(new Data_Tuple.Tuple(m.value5, removeMaxNode(new Data_List_Types.Cons(new ThreeMiddle(m.value0, m.value1, m.value2, max.key, max.value, m.value6), ctx))(m.value3)));+ };+ if (v3 instanceof Data_Ordering.LT) {+ __tco_ctx = new Data_List_Types.Cons(new ThreeLeft(m.value1, m.value2, m.value3, m.value4, m.value5, m.value6), ctx);+ __tco_k = k;+ __tco_m = m.value0;+ return;+ };+ if (v3 instanceof Data_Ordering.GT && v instanceof Data_Ordering.LT) {+ __tco_ctx = new Data_List_Types.Cons(new ThreeMiddle(m.value0, m.value1, m.value2, m.value4, m.value5, m.value6), ctx);+ __tco_k = k;+ __tco_m = m.value3;+ return;+ };+ __tco_ctx = new Data_List_Types.Cons(new ThreeRight(m.value0, m.value1, m.value2, m.value3, m.value4, m.value5), ctx);+ __tco_k = k;+ __tco_m = m.value6;+ return;+ };+ throw new Error("Failed pattern match at Data.Map line 303, column 36 - line 326, column 82: " + [ m.constructor.name ]);+ };+ while (!__tco_done) {+ __tco_result = __tco_loop(ctx, k, m);+ ctx = __tco_ctx;+ k = __tco_k;+ m = __tco_m;+ };+ return __tco_result;+ };+ };+ };+ return down(Data_List_Types.Nil.value);+};+var foldableMap = new Data_Foldable.Foldable(function (dictMonoid) {+ return function (f) {+ return function (m) {+ return Data_Foldable.foldMap(Data_List_Types.foldableList)(dictMonoid)(f)(values(m));+ };+ };+}, function (f) {+ return function (z) {+ return function (m) {+ return Data_Foldable.foldl(Data_List_Types.foldableList)(f)(z)(values(m));+ };+ };+}, function (f) {+ return function (z) {+ return function (m) {+ return Data_Foldable.foldr(Data_List_Types.foldableList)(f)(z)(values(m));+ };+ };+});+var traversableMap = new Data_Traversable.Traversable(function () {+ return foldableMap;+}, function () {+ return functorMap;+}, function (dictApplicative) {+ return Data_Traversable.traverse(traversableMap)(dictApplicative)(Control_Category.id(Control_Category.categoryFn));+}, function (dictApplicative) {+ return function (f) {+ return function (v) {+ if (v instanceof Leaf) {+ return Control_Applicative.pure(dictApplicative)(Leaf.value);+ };+ if (v instanceof Two) {+ return Control_Apply.apply(dictApplicative.Apply0())(Control_Apply.apply(dictApplicative.Apply0())(Control_Apply.apply(dictApplicative.Apply0())(Data_Functor.map((dictApplicative.Apply0()).Functor0())(Two.create)(Data_Traversable.traverse(traversableMap)(dictApplicative)(f)(v.value0)))(Control_Applicative.pure(dictApplicative)(v.value1)))(f(v.value2)))(Data_Traversable.traverse(traversableMap)(dictApplicative)(f)(v.value3));+ };+ if (v instanceof Three) {+ return Control_Apply.apply(dictApplicative.Apply0())(Control_Apply.apply(dictApplicative.Apply0())(Control_Apply.apply(dictApplicative.Apply0())(Control_Apply.apply(dictApplicative.Apply0())(Control_Apply.apply(dictApplicative.Apply0())(Control_Apply.apply(dictApplicative.Apply0())(Data_Functor.map((dictApplicative.Apply0()).Functor0())(Three.create)(Data_Traversable.traverse(traversableMap)(dictApplicative)(f)(v.value0)))(Control_Applicative.pure(dictApplicative)(v.value1)))(f(v.value2)))(Data_Traversable.traverse(traversableMap)(dictApplicative)(f)(v.value3)))(Control_Applicative.pure(dictApplicative)(v.value4)))(f(v.value5)))(Data_Traversable.traverse(traversableMap)(dictApplicative)(f)(v.value6));+ };+ throw new Error("Failed pattern match at Data.Map line 91, column 3 - line 91, column 30: " + [ f.constructor.name, v.constructor.name ]);+ };+ };+});+var findMin = function (v) {+ if (v instanceof Leaf) {+ return Data_Maybe.Nothing.value;+ };+ if (v instanceof Two) {+ return Data_Maybe.Just.create(Data_Maybe.fromMaybe({+ key: v.value1, + value: v.value2+ })(findMin(v.value0)));+ };+ if (v instanceof Three) {+ return Data_Maybe.Just.create(Data_Maybe.fromMaybe({+ key: v.value1, + value: v.value2+ })(findMin(v.value0)));+ };+ throw new Error("Failed pattern match at Data.Map line 229, column 1 - line 229, column 23: " + [ v.constructor.name ]);+};+var lookupGT = function (dictOrd) {+ return function (v) {+ return function (v1) {+ if (v1 instanceof Leaf) {+ return Data_Maybe.Nothing.value;+ };+ if (v1 instanceof Two) {+ var v2 = Data_Ord.compare(dictOrd)(v)(v1.value1);+ if (v2 instanceof Data_Ordering.EQ) {+ return findMin(v1.value3);+ };+ if (v2 instanceof Data_Ordering.LT) {+ return Data_Maybe.Just.create(Data_Maybe.fromMaybe({+ key: v1.value1, + value: v1.value2+ })(lookupGT(dictOrd)(v)(v1.value0)));+ };+ if (v2 instanceof Data_Ordering.GT) {+ return lookupGT(dictOrd)(v)(v1.value3);+ };+ throw new Error("Failed pattern match at Data.Map line 212, column 37 - line 215, column 25: " + [ v2.constructor.name ]);+ };+ if (v1 instanceof Three) {+ var v3 = Data_Ord.compare(dictOrd)(v)(v1.value1);+ if (v3 instanceof Data_Ordering.EQ) {+ return findMin(new Two(v1.value3, v1.value4, v1.value5, v1.value6));+ };+ if (v3 instanceof Data_Ordering.LT) {+ return Data_Maybe.Just.create(Data_Maybe.fromMaybe({+ key: v1.value1, + value: v1.value2+ })(lookupGT(dictOrd)(v)(v1.value0)));+ };+ if (v3 instanceof Data_Ordering.GT) {+ return lookupGT(dictOrd)(v)(new Two(v1.value3, v1.value4, v1.value5, v1.value6));+ };+ throw new Error("Failed pattern match at Data.Map line 216, column 49 - line 219, column 41: " + [ v3.constructor.name ]);+ };+ throw new Error("Failed pattern match at Data.Map line 211, column 1 - line 211, column 26: " + [ v.constructor.name, v1.constructor.name ]);+ };+ };+};+var findMax = function (v) {+ if (v instanceof Leaf) {+ return Data_Maybe.Nothing.value;+ };+ if (v instanceof Two) {+ return Data_Maybe.Just.create(Data_Maybe.fromMaybe({+ key: v.value1, + value: v.value2+ })(findMax(v.value3)));+ };+ if (v instanceof Three) {+ return Data_Maybe.Just.create(Data_Maybe.fromMaybe({+ key: v.value4, + value: v.value5+ })(findMax(v.value6)));+ };+ throw new Error("Failed pattern match at Data.Map line 223, column 1 - line 223, column 23: " + [ v.constructor.name ]);+};+var lookupLT = function (dictOrd) {+ return function (v) {+ return function (v1) {+ if (v1 instanceof Leaf) {+ return Data_Maybe.Nothing.value;+ };+ if (v1 instanceof Two) {+ var v2 = Data_Ord.compare(dictOrd)(v)(v1.value1);+ if (v2 instanceof Data_Ordering.EQ) {+ return findMax(v1.value0);+ };+ if (v2 instanceof Data_Ordering.GT) {+ return Data_Maybe.Just.create(Data_Maybe.fromMaybe({+ key: v1.value1, + value: v1.value2+ })(lookupLT(dictOrd)(v)(v1.value3)));+ };+ if (v2 instanceof Data_Ordering.LT) {+ return lookupLT(dictOrd)(v)(v1.value0);+ };+ throw new Error("Failed pattern match at Data.Map line 188, column 37 - line 191, column 24: " + [ v2.constructor.name ]);+ };+ if (v1 instanceof Three) {+ var v3 = Data_Ord.compare(dictOrd)(v)(v1.value4);+ if (v3 instanceof Data_Ordering.EQ) {+ return findMax(new Two(v1.value0, v1.value1, v1.value2, v1.value3));+ };+ if (v3 instanceof Data_Ordering.GT) {+ return Data_Maybe.Just.create(Data_Maybe.fromMaybe({+ key: v1.value4, + value: v1.value5+ })(lookupLT(dictOrd)(v)(v1.value6)));+ };+ if (v3 instanceof Data_Ordering.LT) {+ return lookupLT(dictOrd)(v)(new Two(v1.value0, v1.value1, v1.value2, v1.value3));+ };+ throw new Error("Failed pattern match at Data.Map line 192, column 49 - line 195, column 40: " + [ v3.constructor.name ]);+ };+ throw new Error("Failed pattern match at Data.Map line 187, column 1 - line 187, column 26: " + [ v.constructor.name, v1.constructor.name ]);+ };+ };+};+var eqMap = function (dictEq) {+ return function (dictEq1) {+ return new Data_Eq.Eq(function (m1) {+ return function (m2) {+ return Data_Eq.eq(Data_Eq.eqArray(Data_Tuple.eqTuple(dictEq)(dictEq1)))(toAscArray(m1))(toAscArray(m2));+ };+ });+ };+};+var ordMap = function (dictOrd) {+ return function (dictOrd1) {+ return new Data_Ord.Ord(function () {+ return eqMap(dictOrd.Eq0())(dictOrd1.Eq0());+ }, function (m1) {+ return function (m2) {+ return Data_Ord.compare(Data_Ord.ordArray(Data_Tuple.ordTuple(dictOrd)(dictOrd1)))(toAscArray(m1))(toAscArray(m2));+ };+ });+ };+};+var eq1Map = function (dictEq) {+ return new Data_Eq.Eq1(function (dictEq1) {+ return Data_Eq.eq(eqMap(dictEq)(dictEq1));+ });+};+var ord1Map = function (dictOrd) {+ return new Data_Ord.Ord1(function () {+ return eq1Map(dictOrd.Eq0());+ }, function (dictOrd1) {+ return Data_Ord.compare(ordMap(dictOrd)(dictOrd1));+ });+};+var empty = Leaf.value;+var fromFoldable = function (dictOrd) {+ return function (dictFoldable) {+ return Data_Foldable.foldl(dictFoldable)(function (m) {+ return function (v) {+ return insert(dictOrd)(v.value0)(v.value1)(m);+ };+ })(empty);+ };+};+var $$delete = function (dictOrd) {+ return function (k) {+ return function (m) {+ return Data_Maybe.maybe(m)(Data_Tuple.snd)(pop(dictOrd)(k)(m));+ };+ };+};+var checkValid = function (tree) {+ var allHeights = function (v) {+ if (v instanceof Leaf) {+ return Control_Applicative.pure(Data_List_Types.applicativeList)(0);+ };+ if (v instanceof Two) {+ return Data_Functor.map(Data_List_Types.functorList)(function (n) {+ return n + 1 | 0;+ })(Data_Semigroup.append(Data_List_Types.semigroupList)(allHeights(v.value0))(allHeights(v.value3)));+ };+ if (v instanceof Three) {+ return Data_Functor.map(Data_List_Types.functorList)(function (n) {+ return n + 1 | 0;+ })(Data_Semigroup.append(Data_List_Types.semigroupList)(allHeights(v.value0))(Data_Semigroup.append(Data_List_Types.semigroupList)(allHeights(v.value3))(allHeights(v.value6))));+ };+ throw new Error("Failed pattern match at Data.Map line 144, column 3 - line 144, column 30: " + [ v.constructor.name ]);+ };+ return Data_List.length(Data_List.nub(Data_Eq.eqInt)(allHeights(tree))) === 1;+};+var alter = function (dictOrd) {+ return function (f) {+ return function (k) {+ return function (m) {+ var v = f(lookup(dictOrd)(k)(m));+ if (v instanceof Data_Maybe.Nothing) {+ return $$delete(dictOrd)(k)(m);+ };+ if (v instanceof Data_Maybe.Just) {+ return insert(dictOrd)(k)(v.value0)(m);+ };+ throw new Error("Failed pattern match at Data.Map line 371, column 15 - line 373, column 25: " + [ v.constructor.name ]);+ };+ };+ };+};+var fromFoldableWith = function (dictOrd) {+ return function (dictFoldable) {+ return function (f) {+ var combine = function (v) {+ return function (v1) {+ if (v1 instanceof Data_Maybe.Just) {+ return Data_Maybe.Just.create(f(v)(v1.value0));+ };+ if (v1 instanceof Data_Maybe.Nothing) {+ return new Data_Maybe.Just(v);+ };+ throw new Error("Failed pattern match at Data.Map line 388, column 3 - line 388, column 38: " + [ v.constructor.name, v1.constructor.name ]);+ };+ };+ return Data_Foldable.foldl(dictFoldable)(function (m) {+ return function (v) {+ return alter(dictOrd)(combine(v.value1))(v.value0)(m);+ };+ })(empty);+ };+ };+};+var unionWith = function (dictOrd) {+ return function (f) {+ return function (m1) {+ return function (m2) {+ var go = function (m) {+ return function (v) {+ return alter(dictOrd)(function ($674) {+ return Data_Maybe.Just.create(Data_Maybe.maybe(v.value1)(f(v.value1))($674));+ })(v.value0)(m);+ };+ };+ return Data_Foldable.foldl(Data_List_Types.foldableList)(go)(m2)(toUnfoldable(Data_List_Types.unfoldableList)(m1));+ };+ };+ };+};+var union = function (dictOrd) {+ return unionWith(dictOrd)(Data_Function["const"]);+};+var semigroupMap = function (dictOrd) {+ return new Data_Semigroup.Semigroup(union(dictOrd));+};+var monoidMap = function (dictOrd) {+ return new Data_Monoid.Monoid(function () {+ return semigroupMap(dictOrd);+ }, empty);+};+var unions = function (dictOrd) {+ return function (dictFoldable) {+ return Data_Foldable.foldl(dictFoldable)(union(dictOrd))(empty);+ };+};+var update = function (dictOrd) {+ return function (f) {+ return function (k) {+ return function (m) {+ return alter(dictOrd)(Data_Maybe.maybe(Data_Maybe.Nothing.value)(f))(k)(m);+ };+ };+ };+};+module.exports = {+ alter: alter, + checkValid: checkValid, + "delete": $$delete, + empty: empty, + findMax: findMax, + findMin: findMin, + fromFoldable: fromFoldable, + fromFoldableWith: fromFoldableWith, + insert: insert, + isEmpty: isEmpty, + keys: keys, + lookup: lookup, + lookupGE: lookupGE, + lookupGT: lookupGT, + lookupLE: lookupLE, + lookupLT: lookupLT, + mapWithKey: mapWithKey, + member: member, + pop: pop, + showTree: showTree, + singleton: singleton, + size: size, + toAscUnfoldable: toAscUnfoldable, + toUnfoldable: toUnfoldable, + union: union, + unionWith: unionWith, + unions: unions, + update: update, + values: values, + eq1Map: eq1Map, + eqMap: eqMap, + ord1Map: ord1Map, + ordMap: ordMap, + showMap: showMap, + semigroupMap: semigroupMap, + monoidMap: monoidMap, + functorMap: functorMap, + foldableMap: foldableMap, + traversableMap: traversableMap+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Category":47,"../Control.Semigroupoid":92,"../Data.Eq":138,"../Data.Foldable":143,"../Data.Function":149,"../Data.Functor":155,"../Data.List":194,"../Data.List.Types":193,"../Data.Maybe":198,"../Data.Monoid":207,"../Data.Ord":216,"../Data.Ordering":217,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Show":233,"../Data.Traversable":244,"../Data.Tuple":245,"../Data.Unfoldable":247,"../Partial.Unsafe":265,"../Prelude":268}],196:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Extend = require("../Control.Extend");+var Control_Monad = require("../Control.Monad");+var Data_Bounded = require("../Data.Bounded");+var Data_Eq = require("../Data.Eq");+var Data_Functor = require("../Data.Functor");+var Data_Functor_Invariant = require("../Data.Functor.Invariant");+var Data_Maybe = require("../Data.Maybe");+var Data_Monoid = require("../Data.Monoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Prelude = require("../Prelude");+var First = function (x) {+ return x;+};+var showFirst = function (dictShow) {+ return new Data_Show.Show(function (v) {+ return "First (" + (Data_Show.show(Data_Maybe.showMaybe(dictShow))(v) + ")");+ });+};+var semigroupFirst = new Data_Semigroup.Semigroup(function (v) {+ return function (v1) {+ if (v instanceof Data_Maybe.Just) {+ return v;+ };+ return v1;+ };+});+var ordFirst = function (dictOrd) {+ return Data_Maybe.ordMaybe(dictOrd);+};+var ord1First = Data_Maybe.ord1Maybe;+var newtypeFirst = new Data_Newtype.Newtype(function (n) {+ return n;+}, First);+var monoidFirst = new Data_Monoid.Monoid(function () {+ return semigroupFirst;+}, Data_Maybe.Nothing.value);+var monadFirst = Data_Maybe.monadMaybe;+var invariantFirst = Data_Maybe.invariantMaybe;+var functorFirst = Data_Maybe.functorMaybe;+var extendFirst = Data_Maybe.extendMaybe;+var eqFirst = function (dictEq) {+ return Data_Maybe.eqMaybe(dictEq);+};+var eq1First = Data_Maybe.eq1Maybe;+var boundedFirst = function (dictBounded) {+ return Data_Maybe.boundedMaybe(dictBounded);+};+var bindFirst = Data_Maybe.bindMaybe;+var applyFirst = Data_Maybe.applyMaybe;+var applicativeFirst = Data_Maybe.applicativeMaybe;+module.exports = {+ First: First, + newtypeFirst: newtypeFirst, + eqFirst: eqFirst, + eq1First: eq1First, + ordFirst: ordFirst, + ord1First: ord1First, + boundedFirst: boundedFirst, + functorFirst: functorFirst, + invariantFirst: invariantFirst, + applyFirst: applyFirst, + applicativeFirst: applicativeFirst, + bindFirst: bindFirst, + monadFirst: monadFirst, + extendFirst: extendFirst, + showFirst: showFirst, + semigroupFirst: semigroupFirst, + monoidFirst: monoidFirst+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Extend":49,"../Control.Monad":86,"../Data.Bounded":132,"../Data.Eq":138,"../Data.Functor":155,"../Data.Functor.Invariant":153,"../Data.Maybe":198,"../Data.Monoid":207,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Semigroup":229,"../Data.Show":233,"../Prelude":268}],197:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Extend = require("../Control.Extend");+var Control_Monad = require("../Control.Monad");+var Data_Bounded = require("../Data.Bounded");+var Data_Eq = require("../Data.Eq");+var Data_Functor = require("../Data.Functor");+var Data_Functor_Invariant = require("../Data.Functor.Invariant");+var Data_Maybe = require("../Data.Maybe");+var Data_Monoid = require("../Data.Monoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Prelude = require("../Prelude");+var Last = function (x) {+ return x;+};+var showLast = function (dictShow) {+ return new Data_Show.Show(function (v) {+ return "(Last " + (Data_Show.show(Data_Maybe.showMaybe(dictShow))(v) + ")");+ });+};+var semigroupLast = new Data_Semigroup.Semigroup(function (v) {+ return function (v1) {+ if (v1 instanceof Data_Maybe.Just) {+ return v1;+ };+ if (v1 instanceof Data_Maybe.Nothing) {+ return v;+ };+ throw new Error("Failed pattern match at Data.Maybe.Last line 54, column 3 - line 54, column 39: " + [ v.constructor.name, v1.constructor.name ]);+ };+});+var ordLast = function (dictOrd) {+ return Data_Maybe.ordMaybe(dictOrd);+};+var ord1Last = Data_Maybe.ord1Maybe;+var newtypeLast = new Data_Newtype.Newtype(function (n) {+ return n;+}, Last);+var monoidLast = new Data_Monoid.Monoid(function () {+ return semigroupLast;+}, Data_Maybe.Nothing.value);+var monadLast = Data_Maybe.monadMaybe;+var invariantLast = Data_Maybe.invariantMaybe;+var functorLast = Data_Maybe.functorMaybe;+var extendLast = Data_Maybe.extendMaybe;+var eqLast = function (dictEq) {+ return Data_Maybe.eqMaybe(dictEq);+};+var eq1Last = Data_Maybe.eq1Maybe;+var boundedLast = function (dictBounded) {+ return Data_Maybe.boundedMaybe(dictBounded);+};+var bindLast = Data_Maybe.bindMaybe;+var applyLast = Data_Maybe.applyMaybe;+var applicativeLast = Data_Maybe.applicativeMaybe;+module.exports = {+ Last: Last, + newtypeLast: newtypeLast, + eqLast: eqLast, + eq1Last: eq1Last, + ordLast: ordLast, + ord1Last: ord1Last, + boundedLast: boundedLast, + functorLast: functorLast, + invariantLast: invariantLast, + applyLast: applyLast, + applicativeLast: applicativeLast, + bindLast: bindLast, + monadLast: monadLast, + extendLast: extendLast, + showLast: showLast, + semigroupLast: semigroupLast, + monoidLast: monoidLast+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Extend":49,"../Control.Monad":86,"../Data.Bounded":132,"../Data.Eq":138,"../Data.Functor":155,"../Data.Functor.Invariant":153,"../Data.Maybe":198,"../Data.Monoid":207,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Semigroup":229,"../Data.Show":233,"../Prelude":268}],198:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Control_Alternative = require("../Control.Alternative");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Category = require("../Control.Category");+var Control_Extend = require("../Control.Extend");+var Control_Monad = require("../Control.Monad");+var Control_MonadZero = require("../Control.MonadZero");+var Control_Plus = require("../Control.Plus");+var Data_Bounded = require("../Data.Bounded");+var Data_Eq = require("../Data.Eq");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Functor_Invariant = require("../Data.Functor.Invariant");+var Data_Monoid = require("../Data.Monoid");+var Data_Ord = require("../Data.Ord");+var Data_Ordering = require("../Data.Ordering");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../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 showMaybe = function (dictShow) {+ return new Data_Show.Show(function (v) {+ if (v instanceof Just) {+ return "(Just " + (Data_Show.show(dictShow)(v.value0) + ")");+ };+ if (v instanceof Nothing) {+ return "Nothing";+ };+ throw new Error("Failed pattern match at Data.Maybe line 208, column 3 - line 209, column 3: " + [ v.constructor.name ]);+ });+};+var semigroupMaybe = function (dictSemigroup) {+ return new Data_Semigroup.Semigroup(function (v) {+ return function (v1) {+ if (v instanceof Nothing) {+ return v1;+ };+ if (v1 instanceof Nothing) {+ return v;+ };+ if (v instanceof Just && v1 instanceof Just) {+ return new Just(Data_Semigroup.append(dictSemigroup)(v.value0)(v1.value0));+ };+ throw new Error("Failed pattern match at Data.Maybe line 177, column 3 - line 177, column 23: " + [ v.constructor.name, v1.constructor.name ]);+ };+ });+};+var monoidMaybe = function (dictSemigroup) {+ return new Data_Monoid.Monoid(function () {+ return semigroupMaybe(dictSemigroup);+ }, Nothing.value);+};+var maybe$prime = function (v) {+ return function (v1) {+ return function (v2) {+ if (v2 instanceof Nothing) {+ return v(Data_Unit.unit);+ };+ if (v2 instanceof Just) {+ return v1(v2.value0);+ };+ throw new Error("Failed pattern match at Data.Maybe line 233, column 1 - line 233, column 28: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);+ };+ };+};+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 220, column 1 - line 220, column 22: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);+ };+ };+};+var isNothing = maybe(true)(Data_Function["const"](false));+var isJust = maybe(false)(Data_Function["const"](true));+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 invariantMaybe = new Data_Functor_Invariant.Invariant(Data_Functor_Invariant.imapF(functorMaybe));+var fromMaybe$prime = function (a) {+ return maybe$prime(a)(Control_Category.id(Control_Category.categoryFn));+};+var fromMaybe = function (a) {+ return maybe(a)(Control_Category.id(Control_Category.categoryFn));+};+var fromJust = function (dictPartial) {+ return function (v) {+ var __unused = function (dictPartial1) {+ return function ($dollar34) {+ return $dollar34;+ };+ };+ return __unused(dictPartial)((function () {+ if (v instanceof Just) {+ return v.value0;+ };+ throw new Error("Failed pattern match at Data.Maybe line 271, column 1 - line 271, column 21: " + [ v.constructor.name ]);+ })());+ };+};+var extendMaybe = new Control_Extend.Extend(function () {+ return functorMaybe;+}, function (v) {+ return function (v1) {+ if (v1 instanceof Nothing) {+ return Nothing.value;+ };+ return new Just(v(v1));+ };+});+var eqMaybe = function (dictEq) {+ return new Data_Eq.Eq(function (x) {+ return function (y) {+ if (x instanceof Nothing && y instanceof Nothing) {+ return true;+ };+ if (x instanceof Just && y instanceof Just) {+ return Data_Eq.eq(dictEq)(x.value0)(y.value0);+ };+ return false;+ };+ });+};+var ordMaybe = function (dictOrd) {+ return new Data_Ord.Ord(function () {+ return eqMaybe(dictOrd.Eq0());+ }, function (x) {+ return function (y) {+ if (x instanceof Nothing && y instanceof Nothing) {+ return Data_Ordering.EQ.value;+ };+ if (x instanceof Nothing) {+ return Data_Ordering.LT.value;+ };+ if (y instanceof Nothing) {+ return Data_Ordering.GT.value;+ };+ if (x instanceof Just && y instanceof Just) {+ return Data_Ord.compare(dictOrd)(x.value0)(y.value0);+ };+ throw new Error("Failed pattern match at Data.Maybe line 196, column 1 - line 196, column 51: " + [ x.constructor.name, y.constructor.name ]);+ };+ });+};+var eq1Maybe = new Data_Eq.Eq1(function (dictEq) {+ return Data_Eq.eq(eqMaybe(dictEq));+});+var ord1Maybe = new Data_Ord.Ord1(function () {+ return eq1Maybe;+}, function (dictOrd) {+ return Data_Ord.compare(ordMaybe(dictOrd));+});+var boundedMaybe = function (dictBounded) {+ return new Data_Bounded.Bounded(function () {+ return ordMaybe(dictBounded.Ord0());+ }, Nothing.value, new Just(Data_Bounded.top(dictBounded)));+};+var applyMaybe = new Control_Apply.Apply(function () {+ return functorMaybe;+}, function (v) {+ return function (v1) {+ if (v instanceof Just) {+ return Data_Functor.map(functorMaybe)(v.value0)(v1);+ };+ if (v instanceof Nothing) {+ return Nothing.value;+ };+ throw new Error("Failed pattern match at Data.Maybe line 69, column 3 - line 69, column 31: " + [ v.constructor.name, v1.constructor.name ]);+ };+});+var bindMaybe = new Control_Bind.Bind(function () {+ return applyMaybe;+}, function (v) {+ return function (v1) {+ if (v instanceof Just) {+ return v1(v.value0);+ };+ if (v instanceof Nothing) {+ return Nothing.value;+ };+ throw new Error("Failed pattern match at Data.Maybe line 128, column 3 - line 128, column 24: " + [ v.constructor.name, v1.constructor.name ]);+ };+});+var applicativeMaybe = new Control_Applicative.Applicative(function () {+ return applyMaybe;+}, Just.create);+var monadMaybe = new Control_Monad.Monad(function () {+ return applicativeMaybe;+}, function () {+ return bindMaybe;+});+var altMaybe = new Control_Alt.Alt(function () {+ return functorMaybe;+}, function (v) {+ return function (v1) {+ if (v instanceof Nothing) {+ return v1;+ };+ return v;+ };+});+var plusMaybe = new Control_Plus.Plus(function () {+ return altMaybe;+}, Nothing.value);+var alternativeMaybe = new Control_Alternative.Alternative(function () {+ return applicativeMaybe;+}, function () {+ return plusMaybe;+});+var monadZeroMaybe = new Control_MonadZero.MonadZero(function () {+ return alternativeMaybe;+}, function () {+ return monadMaybe;+});+module.exports = {+ Nothing: Nothing, + Just: Just, + fromJust: fromJust, + fromMaybe: fromMaybe, + "fromMaybe'": fromMaybe$prime, + isJust: isJust, + isNothing: isNothing, + maybe: maybe, + "maybe'": maybe$prime, + functorMaybe: functorMaybe, + applyMaybe: applyMaybe, + applicativeMaybe: applicativeMaybe, + altMaybe: altMaybe, + plusMaybe: plusMaybe, + alternativeMaybe: alternativeMaybe, + bindMaybe: bindMaybe, + monadMaybe: monadMaybe, + monadZeroMaybe: monadZeroMaybe, + extendMaybe: extendMaybe, + invariantMaybe: invariantMaybe, + semigroupMaybe: semigroupMaybe, + monoidMaybe: monoidMaybe, + eqMaybe: eqMaybe, + eq1Maybe: eq1Maybe, + ordMaybe: ordMaybe, + ord1Maybe: ord1Maybe, + boundedMaybe: boundedMaybe, + showMaybe: showMaybe+};++},{"../Control.Alt":38,"../Control.Alternative":39,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Category":47,"../Control.Extend":49,"../Control.Monad":86,"../Control.MonadZero":88,"../Control.Plus":91,"../Data.Bounded":132,"../Data.Eq":138,"../Data.Function":149,"../Data.Functor":155,"../Data.Functor.Invariant":153,"../Data.Monoid":207,"../Data.Ord":216,"../Data.Ordering":217,"../Data.Semigroup":229,"../Data.Show":233,"../Data.Unit":249,"../Prelude":268}],199:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_MediaType = require("../Data.MediaType");+var textXML = "text/xml";+var textPlain = "text/plain";+var textHTML = "text/html";+var textCSV = "text/csv";+var multipartFormData = "multipart/form-data";+var imagePNG = "image/png";+var imageJPEG = "image/jpeg";+var imageGIF = "image/gif";+var applicationXML = "application/xml";+var applicationOctetStream = "application/octet-stream";+var applicationJavascript = "application/javascript";+var applicationJSON = "application/json";+var applicationFormURLEncoded = "application/x-www-form-urlencoded";+module.exports = {+ applicationFormURLEncoded: applicationFormURLEncoded, + applicationJSON: applicationJSON, + applicationJavascript: applicationJavascript, + applicationOctetStream: applicationOctetStream, + applicationXML: applicationXML, + imageGIF: imageGIF, + imageJPEG: imageJPEG, + imagePNG: imagePNG, + multipartFormData: multipartFormData, + textCSV: textCSV, + textHTML: textHTML, + textPlain: textPlain, + textXML: textXML+};++},{"../Data.MediaType":200}],200:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Apply = require("../Control.Apply");+var Data_Eq = require("../Data.Eq");+var Data_Generic = require("../Data.Generic");+var Data_Maybe = require("../Data.Maybe");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var MediaType = function (x) {+ return x;+};+var showMediaType = new Data_Show.Show(function (v) {+ return "(MediaType " + (Data_Show.show(Data_Show.showString)(v) + ")");+});+var newtypeMediaType = new Data_Newtype.Newtype(function (n) {+ return n;+}, MediaType);+var genericMediaType = new Data_Generic.Generic(function (v) {+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.MediaType.MediaType" && v.value1.length === 1)) {+ return Control_Apply.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(MediaType))(Data_Generic.fromSpine(Data_Generic.genericString)(v["value1"][0](Data_Unit.unit)));+ };+ return Data_Maybe.Nothing.value;+}, function ($dollarq) {+ return new Data_Generic.SigProd("Data.MediaType.MediaType", [ {+ sigConstructor: "Data.MediaType.MediaType", + sigValues: [ function ($dollarq1) {+ return Data_Generic.toSignature(Data_Generic.genericString)(Data_Generic.anyProxy);+ } ]+ } ]);+}, function (v) {+ return new Data_Generic.SProd("Data.MediaType.MediaType", [ function ($dollarq) {+ return Data_Generic.toSpine(Data_Generic.genericString)(v);+ } ]);+});+var eqMediaType = new Data_Eq.Eq(function (x) {+ return function (y) {+ return x === y;+ };+});+var ordMediaType = new Data_Ord.Ord(function () {+ return eqMediaType;+}, function (x) {+ return function (y) {+ return Data_Ord.compare(Data_Ord.ordString)(x)(y);+ };+});+module.exports = {+ MediaType: MediaType, + newtypeMediaType: newtypeMediaType, + eqMediaType: eqMediaType, + ordMediaType: ordMediaType, + genericMediaType: genericMediaType, + showMediaType: showMediaType+};++},{"../Control.Apply":42,"../Data.Eq":138,"../Data.Generic":157,"../Data.Maybe":198,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Semigroup":229,"../Data.Show":233,"../Data.Unit":249,"../Prelude":268}],201:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Comonad = require("../Control.Comonad");+var Control_Extend = require("../Control.Extend");+var Control_Monad = require("../Control.Monad");+var Data_Bounded = require("../Data.Bounded");+var Data_Eq = require("../Data.Eq");+var Data_Functor = require("../Data.Functor");+var Data_Functor_Invariant = require("../Data.Functor.Invariant");+var Data_Monoid = require("../Data.Monoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Show = require("../Data.Show");+var Prelude = require("../Prelude");+var Additive = function (x) {+ return x;+};+var showAdditive = function (dictShow) {+ return new Data_Show.Show(function (v) {+ return "(Additive " + (Data_Show.show(dictShow)(v) + ")");+ });+};+var semigroupAdditive = function (dictSemiring) {+ return new Data_Semigroup.Semigroup(function (v) {+ return function (v1) {+ return Data_Semiring.add(dictSemiring)(v)(v1);+ };+ });+};+var ordAdditive = function (dictOrd) {+ return dictOrd;+};+var newtypeAdditive = new Data_Newtype.Newtype(function (n) {+ return n;+}, Additive);+var monoidAdditive = function (dictSemiring) {+ return new Data_Monoid.Monoid(function () {+ return semigroupAdditive(dictSemiring);+ }, Data_Semiring.zero(dictSemiring));+};+var invariantAdditive = new Data_Functor_Invariant.Invariant(function (f) {+ return function (v) {+ return function (v1) {+ return f(v1);+ };+ };+});+var functorAdditive = new Data_Functor.Functor(function (f) {+ return function (v) {+ return f(v);+ };+});+var extendAdditive = new Control_Extend.Extend(function () {+ return functorAdditive;+}, function (f) {+ return function (x) {+ return f(x);+ };+});+var eqAdditive = function (dictEq) {+ return dictEq;+};+var comonadAdditive = new Control_Comonad.Comonad(function () {+ return extendAdditive;+}, Data_Newtype.unwrap(newtypeAdditive));+var boundedAdditive = function (dictBounded) {+ return dictBounded;+};+var applyAdditive = new Control_Apply.Apply(function () {+ return functorAdditive;+}, function (v) {+ return function (v1) {+ return v(v1);+ };+});+var bindAdditive = new Control_Bind.Bind(function () {+ return applyAdditive;+}, function (v) {+ return function (f) {+ return f(v);+ };+});+var applicativeAdditive = new Control_Applicative.Applicative(function () {+ return applyAdditive;+}, Additive);+var monadAdditive = new Control_Monad.Monad(function () {+ return applicativeAdditive;+}, function () {+ return bindAdditive;+});+module.exports = {+ Additive: Additive, + newtypeAdditive: newtypeAdditive, + eqAdditive: eqAdditive, + ordAdditive: ordAdditive, + boundedAdditive: boundedAdditive, + functorAdditive: functorAdditive, + invariantAdditive: invariantAdditive, + applyAdditive: applyAdditive, + applicativeAdditive: applicativeAdditive, + bindAdditive: bindAdditive, + monadAdditive: monadAdditive, + extendAdditive: extendAdditive, + comonadAdditive: comonadAdditive, + showAdditive: showAdditive, + semigroupAdditive: semigroupAdditive, + monoidAdditive: monoidAdditive+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Comonad":48,"../Control.Extend":49,"../Control.Monad":86,"../Data.Bounded":132,"../Data.Eq":138,"../Data.Functor":155,"../Data.Functor.Invariant":153,"../Data.Monoid":207,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Show":233,"../Prelude":268}],202:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Comonad = require("../Control.Comonad");+var Control_Extend = require("../Control.Extend");+var Control_Monad = require("../Control.Monad");+var Data_Bounded = require("../Data.Bounded");+var Data_Eq = require("../Data.Eq");+var Data_Functor = require("../Data.Functor");+var Data_Functor_Invariant = require("../Data.Functor.Invariant");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Monoid = require("../Data.Monoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Show = require("../Data.Show");+var Prelude = require("../Prelude");+var Conj = function (x) {+ return x;+};+var showConj = function (dictShow) {+ return new Data_Show.Show(function (v) {+ return "(Conj " + (Data_Show.show(dictShow)(v) + ")");+ });+};+var semiringConj = function (dictHeytingAlgebra) {+ return new Data_Semiring.Semiring(function (v) {+ return function (v1) {+ return Data_HeytingAlgebra.conj(dictHeytingAlgebra)(v)(v1);+ };+ }, function (v) {+ return function (v1) {+ return Data_HeytingAlgebra.disj(dictHeytingAlgebra)(v)(v1);+ };+ }, Data_HeytingAlgebra.ff(dictHeytingAlgebra), Data_HeytingAlgebra.tt(dictHeytingAlgebra));+};+var semigroupConj = function (dictHeytingAlgebra) {+ return new Data_Semigroup.Semigroup(function (v) {+ return function (v1) {+ return Data_HeytingAlgebra.conj(dictHeytingAlgebra)(v)(v1);+ };+ });+};+var ordConj = function (dictOrd) {+ return dictOrd;+};+var newtypeConj = new Data_Newtype.Newtype(function (n) {+ return n;+}, Conj);+var monoidConj = function (dictHeytingAlgebra) {+ return new Data_Monoid.Monoid(function () {+ return semigroupConj(dictHeytingAlgebra);+ }, Data_HeytingAlgebra.tt(dictHeytingAlgebra));+};+var invariantConj = new Data_Functor_Invariant.Invariant(function (f) {+ return function (v) {+ return function (v1) {+ return f(v1);+ };+ };+});+var functorConj = new Data_Functor.Functor(function (f) {+ return function (v) {+ return f(v);+ };+});+var extendConj = new Control_Extend.Extend(function () {+ return functorConj;+}, function (f) {+ return function (x) {+ return f(x);+ };+});+var eqConj = function (dictEq) {+ return dictEq;+};+var comonadConj = new Control_Comonad.Comonad(function () {+ return extendConj;+}, Data_Newtype.unwrap(newtypeConj));+var boundedConj = function (dictBounded) {+ return dictBounded;+};+var applyConj = new Control_Apply.Apply(function () {+ return functorConj;+}, function (v) {+ return function (v1) {+ return v(v1);+ };+});+var bindConj = new Control_Bind.Bind(function () {+ return applyConj;+}, function (v) {+ return function (f) {+ return f(v);+ };+});+var applicativeConj = new Control_Applicative.Applicative(function () {+ return applyConj;+}, Conj);+var monadConj = new Control_Monad.Monad(function () {+ return applicativeConj;+}, function () {+ return bindConj;+});+module.exports = {+ Conj: Conj, + newtypeConj: newtypeConj, + eqConj: eqConj, + ordConj: ordConj, + boundedConj: boundedConj, + functorConj: functorConj, + invariantConj: invariantConj, + applyConj: applyConj, + applicativeConj: applicativeConj, + bindConj: bindConj, + monadConj: monadConj, + extendConj: extendConj, + comonadConj: comonadConj, + showConj: showConj, + semigroupConj: semigroupConj, + monoidConj: monoidConj, + semiringConj: semiringConj+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Comonad":48,"../Control.Extend":49,"../Control.Monad":86,"../Data.Bounded":132,"../Data.Eq":138,"../Data.Functor":155,"../Data.Functor.Invariant":153,"../Data.HeytingAlgebra":160,"../Data.Monoid":207,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Show":233,"../Prelude":268}],203:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Comonad = require("../Control.Comonad");+var Control_Extend = require("../Control.Extend");+var Control_Monad = require("../Control.Monad");+var Data_Bounded = require("../Data.Bounded");+var Data_Eq = require("../Data.Eq");+var Data_Functor = require("../Data.Functor");+var Data_Functor_Invariant = require("../Data.Functor.Invariant");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Monoid = require("../Data.Monoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Show = require("../Data.Show");+var Prelude = require("../Prelude");+var Disj = function (x) {+ return x;+};+var showDisj = function (dictShow) {+ return new Data_Show.Show(function (v) {+ return "(Disj " + (Data_Show.show(dictShow)(v) + ")");+ });+};+var semiringDisj = function (dictHeytingAlgebra) {+ return new Data_Semiring.Semiring(function (v) {+ return function (v1) {+ return Data_HeytingAlgebra.disj(dictHeytingAlgebra)(v)(v1);+ };+ }, function (v) {+ return function (v1) {+ return Data_HeytingAlgebra.conj(dictHeytingAlgebra)(v)(v1);+ };+ }, Data_HeytingAlgebra.tt(dictHeytingAlgebra), Data_HeytingAlgebra.ff(dictHeytingAlgebra));+};+var semigroupDisj = function (dictHeytingAlgebra) {+ return new Data_Semigroup.Semigroup(function (v) {+ return function (v1) {+ return Data_HeytingAlgebra.disj(dictHeytingAlgebra)(v)(v1);+ };+ });+};+var ordDisj = function (dictOrd) {+ return dictOrd;+};+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 invariantDisj = new Data_Functor_Invariant.Invariant(function (f) {+ return function (v) {+ return function (v1) {+ return f(v1);+ };+ };+});+var functorDisj = new Data_Functor.Functor(function (f) {+ return function (v) {+ return f(v);+ };+});+var extendDisj = new Control_Extend.Extend(function () {+ return functorDisj;+}, function (f) {+ return function (x) {+ return f(x);+ };+});+var eqDisj = function (dictEq) {+ return dictEq;+};+var comonadDisj = new Control_Comonad.Comonad(function () {+ return extendDisj;+}, Data_Newtype.unwrap(newtypeDisj));+var boundedDisj = function (dictBounded) {+ return dictBounded;+};+var applyDisj = new Control_Apply.Apply(function () {+ return functorDisj;+}, function (v) {+ return function (v1) {+ return v(v1);+ };+});+var bindDisj = new Control_Bind.Bind(function () {+ return applyDisj;+}, function (v) {+ return function (f) {+ return f(v);+ };+});+var applicativeDisj = new Control_Applicative.Applicative(function () {+ return applyDisj;+}, Disj);+var monadDisj = new Control_Monad.Monad(function () {+ return applicativeDisj;+}, function () {+ return bindDisj;+});+module.exports = {+ Disj: Disj, + newtypeDisj: newtypeDisj, + eqDisj: eqDisj, + ordDisj: ordDisj, + boundedDisj: boundedDisj, + functorDisj: functorDisj, + invariantDisj: invariantDisj, + applyDisj: applyDisj, + applicativeDisj: applicativeDisj, + bindDisj: bindDisj, + monadDisj: monadDisj, + extendDisj: extendDisj, + comonadDisj: comonadDisj, + showDisj: showDisj, + semigroupDisj: semigroupDisj, + monoidDisj: monoidDisj, + semiringDisj: semiringDisj+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Comonad":48,"../Control.Extend":49,"../Control.Monad":86,"../Data.Bounded":132,"../Data.Eq":138,"../Data.Functor":155,"../Data.Functor.Invariant":153,"../Data.HeytingAlgebra":160,"../Data.Monoid":207,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Show":233,"../Prelude":268}],204:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Comonad = require("../Control.Comonad");+var Control_Extend = require("../Control.Extend");+var Control_Monad = require("../Control.Monad");+var Data_Bounded = require("../Data.Bounded");+var Data_Eq = require("../Data.Eq");+var Data_Functor = require("../Data.Functor");+var Data_Functor_Invariant = require("../Data.Functor.Invariant");+var Data_Monoid = require("../Data.Monoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Prelude = require("../Prelude");+var Dual = function (x) {+ return x;+};+var showDual = function (dictShow) {+ return new Data_Show.Show(function (v) {+ return "(Dual " + (Data_Show.show(dictShow)(v) + ")");+ });+};+var semigroupDual = function (dictSemigroup) {+ return new Data_Semigroup.Semigroup(function (v) {+ return function (v1) {+ return Data_Semigroup.append(dictSemigroup)(v1)(v);+ };+ });+};+var ordDual = function (dictOrd) {+ return dictOrd;+};+var newtypeDual = new Data_Newtype.Newtype(function (n) {+ return n;+}, Dual);+var monoidDual = function (dictMonoid) {+ return new Data_Monoid.Monoid(function () {+ return semigroupDual(dictMonoid.Semigroup0());+ }, Data_Monoid.mempty(dictMonoid));+};+var invariantDual = new Data_Functor_Invariant.Invariant(function (f) {+ return function (v) {+ return function (v1) {+ return f(v1);+ };+ };+});+var functorDual = new Data_Functor.Functor(function (f) {+ return function (v) {+ return f(v);+ };+});+var extendDual = new Control_Extend.Extend(function () {+ return functorDual;+}, function (f) {+ return function (x) {+ return f(x);+ };+});+var eqDual = function (dictEq) {+ return dictEq;+};+var comonadDual = new Control_Comonad.Comonad(function () {+ return extendDual;+}, Data_Newtype.unwrap(newtypeDual));+var boundedDual = function (dictBounded) {+ return dictBounded;+};+var applyDual = new Control_Apply.Apply(function () {+ return functorDual;+}, function (v) {+ return function (v1) {+ return v(v1);+ };+});+var bindDual = new Control_Bind.Bind(function () {+ return applyDual;+}, function (v) {+ return function (f) {+ return f(v);+ };+});+var applicativeDual = new Control_Applicative.Applicative(function () {+ return applyDual;+}, Dual);+var monadDual = new Control_Monad.Monad(function () {+ return applicativeDual;+}, function () {+ return bindDual;+});+module.exports = {+ Dual: Dual, + newtypeDual: newtypeDual, + eqDual: eqDual, + ordDual: ordDual, + boundedDual: boundedDual, + functorDual: functorDual, + invariantDual: invariantDual, + applyDual: applyDual, + applicativeDual: applicativeDual, + bindDual: bindDual, + monadDual: monadDual, + extendDual: extendDual, + comonadDual: comonadDual, + showDual: showDual, + semigroupDual: semigroupDual, + monoidDual: monoidDual+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Comonad":48,"../Control.Extend":49,"../Control.Monad":86,"../Data.Bounded":132,"../Data.Eq":138,"../Data.Functor":155,"../Data.Functor.Invariant":153,"../Data.Monoid":207,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Semigroup":229,"../Data.Show":233,"../Prelude":268}],205:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Functor_Invariant = require("../Data.Functor.Invariant");+var Data_Monoid = require("../Data.Monoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Semigroup = require("../Data.Semigroup");+var Prelude = require("../Prelude");+var Endo = function (x) {+ return x;+};+var semigroupEndo = new Data_Semigroup.Semigroup(function (v) {+ return function (v1) {+ return function ($11) {+ return v(v1($11));+ };+ };+});+var newtypeEndo = new Data_Newtype.Newtype(function (n) {+ return n;+}, Endo);+var monoidEndo = new Data_Monoid.Monoid(function () {+ return semigroupEndo;+}, Control_Category.id(Control_Category.categoryFn));+var invariantEndo = new Data_Functor_Invariant.Invariant(function (ab) {+ return function (ba) {+ return function (v) {+ return function ($12) {+ return ab(v(ba($12)));+ };+ };+ };+});+module.exports = {+ Endo: Endo, + newtypeEndo: newtypeEndo, + invariantEndo: invariantEndo, + semigroupEndo: semigroupEndo, + monoidEndo: monoidEndo+};++},{"../Control.Category":47,"../Control.Semigroupoid":92,"../Data.Functor.Invariant":153,"../Data.Monoid":207,"../Data.Newtype":209,"../Data.Semigroup":229,"../Prelude":268}],206:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Comonad = require("../Control.Comonad");+var Control_Extend = require("../Control.Extend");+var Control_Monad = require("../Control.Monad");+var Data_Bounded = require("../Data.Bounded");+var Data_Eq = require("../Data.Eq");+var Data_Functor = require("../Data.Functor");+var Data_Functor_Invariant = require("../Data.Functor.Invariant");+var Data_Monoid = require("../Data.Monoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Show = require("../Data.Show");+var Prelude = require("../Prelude");+var Multiplicative = function (x) {+ return x;+};+var showMultiplicative = function (dictShow) {+ return new Data_Show.Show(function (v) {+ return "(Multiplicative " + (Data_Show.show(dictShow)(v) + ")");+ });+};+var semigroupMultiplicative = function (dictSemiring) {+ return new Data_Semigroup.Semigroup(function (v) {+ return function (v1) {+ return Data_Semiring.mul(dictSemiring)(v)(v1);+ };+ });+};+var ordMultiplicative = function (dictOrd) {+ return dictOrd;+};+var newtypeMultiplicative = new Data_Newtype.Newtype(function (n) {+ return n;+}, Multiplicative);+var monoidMultiplicative = function (dictSemiring) {+ return new Data_Monoid.Monoid(function () {+ return semigroupMultiplicative(dictSemiring);+ }, Data_Semiring.one(dictSemiring));+};+var invariantMultiplicative = new Data_Functor_Invariant.Invariant(function (f) {+ return function (v) {+ return function (v1) {+ return f(v1);+ };+ };+});+var functorMultiplicative = new Data_Functor.Functor(function (f) {+ return function (v) {+ return f(v);+ };+});+var extendMultiplicative = new Control_Extend.Extend(function () {+ return functorMultiplicative;+}, function (f) {+ return function (x) {+ return f(x);+ };+});+var eqMultiplicative = function (dictEq) {+ return dictEq;+};+var comonadMultiplicative = new Control_Comonad.Comonad(function () {+ return extendMultiplicative;+}, Data_Newtype.unwrap(newtypeMultiplicative));+var boundedMultiplicative = function (dictBounded) {+ return dictBounded;+};+var applyMultiplicative = new Control_Apply.Apply(function () {+ return functorMultiplicative;+}, function (v) {+ return function (v1) {+ return v(v1);+ };+});+var bindMultiplicative = new Control_Bind.Bind(function () {+ return applyMultiplicative;+}, function (v) {+ return function (f) {+ return f(v);+ };+});+var applicativeMultiplicative = new Control_Applicative.Applicative(function () {+ return applyMultiplicative;+}, Multiplicative);+var monadMultiplicative = new Control_Monad.Monad(function () {+ return applicativeMultiplicative;+}, function () {+ return bindMultiplicative;+});+module.exports = {+ Multiplicative: Multiplicative, + newtypeMultiplicative: newtypeMultiplicative, + eqMultiplicative: eqMultiplicative, + ordMultiplicative: ordMultiplicative, + boundedMultiplicative: boundedMultiplicative, + functorMultiplicative: functorMultiplicative, + invariantMultiplicative: invariantMultiplicative, + applyMultiplicative: applyMultiplicative, + applicativeMultiplicative: applicativeMultiplicative, + bindMultiplicative: bindMultiplicative, + monadMultiplicative: monadMultiplicative, + extendMultiplicative: extendMultiplicative, + comonadMultiplicative: comonadMultiplicative, + showMultiplicative: showMultiplicative, + semigroupMultiplicative: semigroupMultiplicative, + monoidMultiplicative: monoidMultiplicative+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Comonad":48,"../Control.Extend":49,"../Control.Monad":86,"../Data.Bounded":132,"../Data.Eq":138,"../Data.Functor":155,"../Data.Functor.Invariant":153,"../Data.Monoid":207,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Show":233,"../Prelude":268}],207:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Boolean = require("../Data.Boolean");+var Data_Eq = require("../Data.Eq");+var Data_EuclideanRing = require("../Data.EuclideanRing");+var Data_Function = require("../Data.Function");+var Data_Ord = require("../Data.Ord");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var Monoid = function (Semigroup0, mempty) {+ this.Semigroup0 = Semigroup0;+ this.mempty = mempty;+};+var monoidUnit = new Monoid(function () {+ return Data_Semigroup.semigroupUnit;+}, Data_Unit.unit);+var monoidString = new Monoid(function () {+ return Data_Semigroup.semigroupString;+}, "");+var monoidArray = new Monoid(function () {+ return Data_Semigroup.semigroupArray;+}, [ ]);+var mempty = function (dict) {+ return dict.mempty;+};+var monoidFn = function (dictMonoid) {+ return new Monoid(function () {+ return Data_Semigroup.semigroupFn(dictMonoid.Semigroup0());+ }, Data_Function["const"](mempty(dictMonoid)));+};+var power = function (dictMonoid) {+ return function (x) {+ var go = function (p) {+ if (p <= 0) {+ return mempty(dictMonoid);+ };+ if (p === 1) {+ return x;+ };+ if (p % 2 === 0) {+ var x$prime = go(p / 2 | 0);+ return Data_Semigroup.append(dictMonoid.Semigroup0())(x$prime)(x$prime);+ };+ if (Data_Boolean.otherwise) {+ var x$prime = go(p / 2 | 0);+ return Data_Semigroup.append(dictMonoid.Semigroup0())(x$prime)(Data_Semigroup.append(dictMonoid.Semigroup0())(x$prime)(x));+ };+ throw new Error("Failed pattern match at Data.Monoid line 49, column 3 - line 53, column 57: " + [ p.constructor.name ]);+ };+ return go;+ };+};+module.exports = {+ Monoid: Monoid, + mempty: mempty, + power: power, + monoidUnit: monoidUnit, + monoidFn: monoidFn, + monoidString: monoidString, + monoidArray: monoidArray+};++},{"../Data.Boolean":129,"../Data.Eq":138,"../Data.EuclideanRing":140,"../Data.Function":149,"../Data.Ord":216,"../Data.Semigroup":229,"../Data.Unit":249,"../Prelude":268}],208:[function(require,module,exports){+arguments[4][99][0].apply(exports,arguments)+},{"dup":99}],209:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Prelude = require("../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 underF2 = function (dictFunctor) {+ return function (dictFunctor1) {+ return function (dictNewtype) {+ return function (dictNewtype1) {+ return function (v) {+ return function (f) {+ return function ($50) {+ return function ($51) {+ return Data_Functor.map(dictFunctor1)(unwrap(dictNewtype1))(Data_Function.on(f)(Data_Functor.map(dictFunctor)(wrap(dictNewtype)))($50)($51));+ };+ };+ };+ };+ };+ };+ };+};+var underF = function (dictFunctor) {+ return function (dictFunctor1) {+ return function (dictNewtype) {+ return function (dictNewtype1) {+ return function (v) {+ return function (f) {+ return function ($52) {+ return Data_Functor.map(dictFunctor1)(unwrap(dictNewtype1))(f(Data_Functor.map(dictFunctor)(wrap(dictNewtype))($52)));+ };+ };+ };+ };+ };+ };+};+var under2 = function (dictNewtype) {+ return function (dictNewtype1) {+ return function (v) {+ return function (f) {+ return function ($53) {+ return function ($54) {+ return unwrap(dictNewtype1)(Data_Function.on(f)(wrap(dictNewtype))($53)($54));+ };+ };+ };+ };+ };+};+var under = function (dictNewtype) {+ return function (dictNewtype1) {+ return function (v) {+ return function (f) {+ return function ($55) {+ return unwrap(dictNewtype1)(f(wrap(dictNewtype)($55)));+ };+ };+ };+ };+};+var un = function (dictNewtype) {+ return function (v) {+ return unwrap(dictNewtype);+ };+};+var traverse = function (dictFunctor) {+ return function (dictNewtype) {+ return function (v) {+ return function (f) {+ return function ($56) {+ return Data_Functor.map(dictFunctor)(wrap(dictNewtype))(f(unwrap(dictNewtype)($56)));+ };+ };+ };+ };+};+var overF2 = function (dictFunctor) {+ return function (dictFunctor1) {+ return function (dictNewtype) {+ return function (dictNewtype1) {+ return function (v) {+ return function (f) {+ return function ($57) {+ return function ($58) {+ return Data_Functor.map(dictFunctor1)(wrap(dictNewtype1))(Data_Function.on(f)(Data_Functor.map(dictFunctor)(unwrap(dictNewtype)))($57)($58));+ };+ };+ };+ };+ };+ };+ };+};+var overF = function (dictFunctor) {+ return function (dictFunctor1) {+ return function (dictNewtype) {+ return function (dictNewtype1) {+ return function (v) {+ return function (f) {+ return function ($59) {+ return Data_Functor.map(dictFunctor1)(wrap(dictNewtype1))(f(Data_Functor.map(dictFunctor)(unwrap(dictNewtype))($59)));+ };+ };+ };+ };+ };+ };+};+var over2 = function (dictNewtype) {+ return function (dictNewtype1) {+ return function (v) {+ return function (f) {+ return function ($60) {+ return function ($61) {+ return wrap(dictNewtype1)(Data_Function.on(f)(unwrap(dictNewtype))($60)($61));+ };+ };+ };+ };+ };+};+var over = function (dictNewtype) {+ return function (dictNewtype1) {+ return function (v) {+ return function (f) {+ return function ($62) {+ return wrap(dictNewtype1)(f(unwrap(dictNewtype)($62)));+ };+ };+ };+ };+};+var op = function (dictNewtype) {+ return un(dictNewtype);+};+var collect = function (dictFunctor) {+ return function (dictNewtype) {+ return function (v) {+ return function (f) {+ return function ($63) {+ return wrap(dictNewtype)(f(Data_Functor.map(dictFunctor)(unwrap(dictNewtype))($63)));+ };+ };+ };+ };+};+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)));+ };+ };+ };+ };+ };+ };+};+var ala = function (dictFunctor) {+ return function (dictNewtype) {+ return function (dictNewtype1) {+ return function (v) {+ return function (f) {+ return Data_Functor.map(dictFunctor)(unwrap(dictNewtype))(f(wrap(dictNewtype1)));+ };+ };+ };+ };+};+module.exports = {+ Newtype: Newtype, + ala: ala, + alaF: alaF, + collect: collect, + op: op, + over: over, + over2: over2, + overF: overF, + overF2: overF2, + traverse: traverse, + un: un, + under: under, + under2: under2, + underF: underF, + underF2: underF2, + unwrap: unwrap, + wrap: wrap+};++},{"../Control.Semigroupoid":92,"../Data.Function":149,"../Data.Functor":155,"../Prelude":268}],210:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Control_Alternative = require("../Control.Alternative");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Category = require("../Control.Category");+var Control_Plus = require("../Control.Plus");+var Data_Eq = require("../Data.Eq");+var Data_Foldable = require("../Data.Foldable");+var Data_Functor = require("../Data.Functor");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Ord = require("../Data.Ord");+var Data_Ordering = require("../Data.Ordering");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Data_Traversable = require("../Data.Traversable");+var Prelude = require("../Prelude");+var NonEmpty = (function () {+ function NonEmpty(value0, value1) {+ this.value0 = value0;+ this.value1 = value1;+ };+ NonEmpty.create = function (value0) {+ return function (value1) {+ return new NonEmpty(value0, value1);+ };+ };+ return NonEmpty;+})();+var tail = function (v) {+ return v.value1;+};+var singleton = function (dictPlus) {+ return function (a) {+ return new NonEmpty(a, Control_Plus.empty(dictPlus));+ };+};+var showNonEmpty = function (dictShow) {+ return function (dictShow1) {+ return new Data_Show.Show(function (v) {+ return "(NonEmpty " + (Data_Show.show(dictShow)(v.value0) + (" " + (Data_Show.show(dictShow1)(v.value1) + ")")));+ });+ };+};+var oneOf = function (dictAlternative) {+ return function (v) {+ return Control_Alt.alt((dictAlternative.Plus1()).Alt0())(Control_Applicative.pure(dictAlternative.Applicative0())(v.value0))(v.value1);+ };+};+var head = function (v) {+ return v.value0;+};+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));+ };+ });+};+var fromNonEmpty = function (f) {+ return function (v) {+ return f(v.value0)(v.value1);+ };+};+var foldl1 = function (dictFoldable) {+ return function (f) {+ return function (v) {+ return Data_Foldable.foldl(dictFoldable)(f)(v.value0)(v.value1);+ };+ };+};+var foldableNonEmpty = function (dictFoldable) {+ return new Data_Foldable.Foldable(function (dictMonoid) {+ return function (f) {+ return function (v) {+ return Data_Semigroup.append(dictMonoid.Semigroup0())(f(v.value0))(Data_Foldable.foldMap(dictFoldable)(dictMonoid)(f)(v.value1));+ };+ };+ }, function (f) {+ return function (b) {+ return function (v) {+ return Data_Foldable.foldl(dictFoldable)(f)(f(b)(v.value0))(v.value1);+ };+ };+ }, function (f) {+ return function (b) {+ return function (v) {+ return f(v.value0)(Data_Foldable.foldr(dictFoldable)(f)(b)(v.value1));+ };+ };+ });+};+var traversableNonEmpty = function (dictTraversable) {+ return new Data_Traversable.Traversable(function () {+ return foldableNonEmpty(dictTraversable.Foldable1());+ }, function () {+ return functorNonEmpty(dictTraversable.Functor0());+ }, function (dictApplicative) {+ return function (v) {+ return Control_Apply.apply(dictApplicative.Apply0())(Data_Functor.map((dictApplicative.Apply0()).Functor0())(NonEmpty.create)(v.value0))(Data_Traversable.sequence(dictTraversable)(dictApplicative)(v.value1));+ };+ }, function (dictApplicative) {+ return function (f) {+ return function (v) {+ return Control_Apply.apply(dictApplicative.Apply0())(Data_Functor.map((dictApplicative.Apply0()).Functor0())(NonEmpty.create)(f(v.value0)))(Data_Traversable.traverse(dictTraversable)(dictApplicative)(f)(v.value1));+ };+ };+ });+};+var foldMap1 = function (dictSemigroup) {+ return function (dictFoldable) {+ return function (f) {+ return function (v) {+ return Data_Foldable.foldl(dictFoldable)(function (s) {+ return function (a1) {+ return Data_Semigroup.append(dictSemigroup)(s)(f(a1));+ };+ })(f(v.value0))(v.value1);+ };+ };+ };+};+var fold1 = function (dictSemigroup) {+ return function (dictFoldable) {+ return foldMap1(dictSemigroup)(dictFoldable)(Control_Category.id(Control_Category.categoryFn));+ };+};+var eq1NonEmpty = function (dictEq1) {+ return new Data_Eq.Eq1(function (dictEq) {+ return function (v) {+ return function (v1) {+ return Data_Eq.eq(dictEq)(v.value0)(v1.value0) && Data_Eq.eq1(dictEq1)(dictEq)(v.value1)(v1.value1);+ };+ };+ });+};+var eqNonEmpty = function (dictEq1) {+ return function (dictEq) {+ return new Data_Eq.Eq(Data_Eq.eq1(eq1NonEmpty(dictEq1))(dictEq));+ };+};+var ord1NonEmpty = function (dictOrd1) {+ return new Data_Ord.Ord1(function () {+ return eq1NonEmpty(dictOrd1.Eq10());+ }, function (dictOrd) {+ return function (v) {+ return function (v1) {+ var v2 = Data_Ord.compare(dictOrd)(v.value0)(v1.value0);+ if (v2 instanceof Data_Ordering.EQ) {+ return Data_Ord.compare1(dictOrd1)(dictOrd)(v.value1)(v1.value1);+ };+ return v2;+ };+ };+ });+};+var ordNonEmpty = function (dictOrd1) {+ return function (dictOrd) {+ return new Data_Ord.Ord(function () {+ return eqNonEmpty(dictOrd1.Eq10())(dictOrd.Eq0());+ }, Data_Ord.compare1(ord1NonEmpty(dictOrd1))(dictOrd));+ };+};+module.exports = {+ NonEmpty: NonEmpty, + fold1: fold1, + foldMap1: foldMap1, + foldl1: foldl1, + fromNonEmpty: fromNonEmpty, + head: head, + oneOf: oneOf, + singleton: singleton, + tail: tail, + showNonEmpty: showNonEmpty, + eqNonEmpty: eqNonEmpty, + eq1NonEmpty: eq1NonEmpty, + ordNonEmpty: ordNonEmpty, + ord1NonEmpty: ord1NonEmpty, + functorNonEmpty: functorNonEmpty, + foldableNonEmpty: foldableNonEmpty, + traversableNonEmpty: traversableNonEmpty+};++},{"../Control.Alt":38,"../Control.Alternative":39,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Category":47,"../Control.Plus":91,"../Data.Eq":138,"../Data.Foldable":143,"../Data.Functor":155,"../Data.HeytingAlgebra":160,"../Data.Ord":216,"../Data.Ordering":217,"../Data.Semigroup":229,"../Data.Show":233,"../Data.Traversable":244,"../Prelude":268}],211:[function(require,module,exports){+"use strict";++exports["null"] = null;++exports.nullable = function (a, r, f) {+ return a == null ? r : f(a);+};++exports.notNull = function (x) {+ return x;+};++},{}],212:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Eq = require("../Data.Eq");+var Data_Function = require("../Data.Function");+var Data_Function_Uncurried = require("../Data.Function.Uncurried");+var Data_Maybe = require("../Data.Maybe");+var Data_Ord = require("../Data.Ord");+var Data_Show = require("../Data.Show");+var Prelude = require("../Prelude");+var toNullable = Data_Maybe.maybe($foreign["null"])($foreign.notNull);+var toMaybe = function (n) {+ return $foreign.nullable(n, Data_Maybe.Nothing.value, Data_Maybe.Just.create);+};+var showNullable = function (dictShow) {+ return new Data_Show.Show(function ($5) {+ return Data_Maybe.maybe("null")(Data_Show.show(dictShow))(toMaybe($5));+ });+};+var eqNullable = function (dictEq) {+ return new Data_Eq.Eq(Data_Function.on(Data_Eq.eq(Data_Maybe.eqMaybe(dictEq)))(toMaybe));+};+var ordNullable = function (dictOrd) {+ return new Data_Ord.Ord(function () {+ return eqNullable(dictOrd.Eq0());+ }, Data_Function.on(Data_Ord.compare(Data_Maybe.ordMaybe(dictOrd)))(toMaybe));+};+var eq1Nullable = new Data_Eq.Eq1(function (dictEq) {+ return Data_Eq.eq(eqNullable(dictEq));+});+var ord1Nullable = new Data_Ord.Ord1(function () {+ return eq1Nullable;+}, function (dictOrd) {+ return Data_Ord.compare(ordNullable(dictOrd));+});+module.exports = {+ toMaybe: toMaybe, + toNullable: toNullable, + showNullable: showNullable, + eqNullable: eqNullable, + eq1Nullable: eq1Nullable, + ordNullable: ordNullable, + ord1Nullable: ord1Nullable+};++},{"../Control.Semigroupoid":92,"../Data.Eq":138,"../Data.Function":149,"../Data.Function.Uncurried":148,"../Data.Maybe":198,"../Data.Ord":216,"../Data.Show":233,"../Prelude":268,"./foreign":211}],213:[function(require,module,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;+ };+ };+ };+ };+};++},{}],214:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Data_Ordering = require("../Data.Ordering");+var unsafeCompare = $foreign.unsafeCompareImpl(Data_Ordering.LT.value)(Data_Ordering.EQ.value)(Data_Ordering.GT.value);+module.exports = {+ unsafeCompare: unsafeCompare+};++},{"../Data.Ordering":217,"./foreign":213}],215:[function(require,module,exports){+"use strict";++exports.ordArrayImpl = function (f) {+ return function (xs) {+ return function (ys) {+ var i = 0;+ var xlen = xs.length;+ var ylen = ys.length;+ while (i < xlen && i < ylen) {+ var x = xs[i];+ var y = ys[i];+ var o = f(x)(y);+ if (o !== 0) {+ return o;+ }+ i++;+ }+ if (xlen === ylen) {+ return 0;+ } else if (xlen > ylen) {+ return -1;+ } else {+ return 1;+ }+ };+ };+};++},{}],216:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Data_Eq = require("../Data.Eq");+var Data_Function = require("../Data.Function");+var Data_Ord_Unsafe = require("../Data.Ord.Unsafe");+var Data_Ordering = require("../Data.Ordering");+var Data_Ring = require("../Data.Ring");+var Data_Semiring = require("../Data.Semiring");+var Data_Unit = require("../Data.Unit");+var Data_Void = require("../Data.Void");+var Ord = function (Eq0, compare) {+ this.Eq0 = Eq0;+ this.compare = compare;+};+var Ord1 = function (Eq10, compare1) {+ this.Eq10 = Eq10;+ this.compare1 = compare1;+};+var ordVoid = new Ord(function () {+ return Data_Eq.eqVoid;+}, function (v) {+ return function (v1) {+ return Data_Ordering.EQ.value;+ };+});+var ordUnit = new Ord(function () {+ return Data_Eq.eqUnit;+}, function (v) {+ return function (v1) {+ return Data_Ordering.EQ.value;+ };+});+var ordString = new Ord(function () {+ return Data_Eq.eqString;+}, Data_Ord_Unsafe.unsafeCompare);+var ordOrdering = new Ord(function () {+ return Data_Ordering.eqOrdering;+}, function (v) {+ return function (v1) {+ if (v instanceof Data_Ordering.LT && v1 instanceof Data_Ordering.LT) {+ return Data_Ordering.EQ.value;+ };+ if (v instanceof Data_Ordering.EQ && v1 instanceof Data_Ordering.EQ) {+ return Data_Ordering.EQ.value;+ };+ if (v instanceof Data_Ordering.GT && v1 instanceof Data_Ordering.GT) {+ return Data_Ordering.EQ.value;+ };+ if (v instanceof Data_Ordering.LT) {+ return Data_Ordering.LT.value;+ };+ if (v instanceof Data_Ordering.EQ && v1 instanceof Data_Ordering.LT) {+ return Data_Ordering.GT.value;+ };+ if (v instanceof Data_Ordering.EQ && v1 instanceof Data_Ordering.GT) {+ return Data_Ordering.LT.value;+ };+ if (v instanceof Data_Ordering.GT) {+ return Data_Ordering.GT.value;+ };+ throw new Error("Failed pattern match at Data.Ord line 69, column 3 - line 69, column 21: " + [ v.constructor.name, v1.constructor.name ]);+ };+});+var ordNumber = new Ord(function () {+ return Data_Eq.eqNumber;+}, Data_Ord_Unsafe.unsafeCompare);+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 ordBoolean = new Ord(function () {+ return Data_Eq.eqBoolean;+}, Data_Ord_Unsafe.unsafeCompare);+var compare1 = function (dict) {+ return dict.compare1;+};+var compare = function (dict) {+ return dict.compare;+};+var comparing = function (dictOrd) {+ return function (f) {+ return Data_Function.on(compare(dictOrd))(f);+ };+};+var greaterThan = function (dictOrd) {+ return function (a1) {+ return function (a2) {+ var v = compare(dictOrd)(a1)(a2);+ if (v instanceof Data_Ordering.GT) {+ return true;+ };+ return false;+ };+ };+};+var greaterThanOrEq = function (dictOrd) {+ return function (a1) {+ return function (a2) {+ var v = compare(dictOrd)(a1)(a2);+ if (v instanceof Data_Ordering.LT) {+ return false;+ };+ return true;+ };+ };+};+var signum = function (dictOrd) {+ return function (dictRing) {+ return function (x) {+ var $33 = greaterThanOrEq(dictOrd)(x)(Data_Semiring.zero(dictRing.Semiring0()));+ if ($33) {+ return Data_Semiring.one(dictRing.Semiring0());+ };+ return Data_Ring.negate(dictRing)(Data_Semiring.one(dictRing.Semiring0()));+ };+ };+};+var lessThan = function (dictOrd) {+ return function (a1) {+ return function (a2) {+ var v = compare(dictOrd)(a1)(a2);+ if (v instanceof Data_Ordering.LT) {+ return true;+ };+ return false;+ };+ };+};+var lessThanOrEq = function (dictOrd) {+ return function (a1) {+ return function (a2) {+ var v = compare(dictOrd)(a1)(a2);+ if (v instanceof Data_Ordering.GT) {+ return false;+ };+ return true;+ };+ };+};+var max = function (dictOrd) {+ return function (x) {+ return function (y) {+ var v = compare(dictOrd)(x)(y);+ if (v instanceof Data_Ordering.LT) {+ return y;+ };+ if (v instanceof Data_Ordering.EQ) {+ return x;+ };+ if (v instanceof Data_Ordering.GT) {+ return x;+ };+ throw new Error("Failed pattern match at Data.Ord line 123, column 3 - line 126, column 12: " + [ v.constructor.name ]);+ };+ };+};+var min = function (dictOrd) {+ return function (x) {+ return function (y) {+ var v = compare(dictOrd)(x)(y);+ if (v instanceof Data_Ordering.LT) {+ return x;+ };+ if (v instanceof Data_Ordering.EQ) {+ return x;+ };+ if (v instanceof Data_Ordering.GT) {+ return y;+ };+ throw new Error("Failed pattern match at Data.Ord line 114, column 3 - line 117, column 12: " + [ v.constructor.name ]);+ };+ };+};+var ordArray = function (dictOrd) {+ return new Ord(function () {+ return Data_Eq.eqArray(dictOrd.Eq0());+ }, (function () {+ var toDelta = function (x) {+ return function (y) {+ var v = compare(dictOrd)(x)(y);+ if (v instanceof Data_Ordering.EQ) {+ return 0;+ };+ if (v instanceof Data_Ordering.LT) {+ return 1;+ };+ if (v instanceof Data_Ordering.GT) {+ return -1 | 0;+ };+ throw new Error("Failed pattern match at Data.Ord line 61, column 7 - line 66, column 1: " + [ v.constructor.name ]);+ };+ };+ return function (xs) {+ return function (ys) {+ return compare(ordInt)(0)($foreign.ordArrayImpl(toDelta)(xs)(ys));+ };+ };+ })());+};+var ord1Array = new Ord1(function () {+ return Data_Eq.eq1Array;+}, function (dictOrd) {+ return compare(ordArray(dictOrd));+});+var clamp = function (dictOrd) {+ return function (low) {+ return function (hi) {+ return function (x) {+ return min(dictOrd)(hi)(max(dictOrd)(low)(x));+ };+ };+ };+};+var between = function (dictOrd) {+ return function (low) {+ return function (hi) {+ return function (x) {+ if (lessThan(dictOrd)(x)(low)) {+ return false;+ };+ if (greaterThan(dictOrd)(x)(hi)) {+ return false;+ };+ return true;+ };+ };+ };+};+var abs = function (dictOrd) {+ return function (dictRing) {+ return function (x) {+ var $42 = greaterThanOrEq(dictOrd)(x)(Data_Semiring.zero(dictRing.Semiring0()));+ if ($42) {+ return x;+ };+ return Data_Ring.negate(dictRing)(x);+ };+ };+};+module.exports = {+ Ord: Ord, + Ord1: Ord1, + abs: abs, + between: between, + clamp: clamp, + compare: compare, + compare1: compare1, + comparing: comparing, + greaterThan: greaterThan, + greaterThanOrEq: greaterThanOrEq, + lessThan: lessThan, + lessThanOrEq: lessThanOrEq, + max: max, + min: min, + signum: signum, + ordBoolean: ordBoolean, + ordInt: ordInt, + ordNumber: ordNumber, + ordString: ordString, + ordChar: ordChar, + ordUnit: ordUnit, + ordVoid: ordVoid, + ordArray: ordArray, + ordOrdering: ordOrdering, + ord1Array: ord1Array+};++},{"../Data.Eq":138,"../Data.Function":149,"../Data.Ord.Unsafe":214,"../Data.Ordering":217,"../Data.Ring":227,"../Data.Semiring":231,"../Data.Unit":249,"../Data.Void":250,"./foreign":215}],217:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Eq = require("../Data.Eq");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../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;+})();+var showOrdering = new Data_Show.Show(function (v) {+ if (v instanceof LT) {+ return "LT";+ };+ if (v instanceof GT) {+ return "GT";+ };+ if (v instanceof EQ) {+ return "EQ";+ };+ throw new Error("Failed pattern match at Data.Ordering line 27, column 3 - line 28, column 3: " + [ v.constructor.name ]);+});+var semigroupOrdering = new Data_Semigroup.Semigroup(function (v) {+ return function (v1) {+ if (v instanceof LT) {+ return LT.value;+ };+ if (v instanceof GT) {+ return GT.value;+ };+ if (v instanceof EQ) {+ return v1;+ };+ throw new Error("Failed pattern match at Data.Ordering line 22, column 3 - line 22, column 19: " + [ v.constructor.name, v1.constructor.name ]);+ };+});+var invert = function (v) {+ if (v instanceof GT) {+ return LT.value;+ };+ if (v instanceof EQ) {+ return EQ.value;+ };+ if (v instanceof LT) {+ return GT.value;+ };+ throw new Error("Failed pattern match at Data.Ordering line 34, column 1 - line 34, column 15: " + [ v.constructor.name ]);+};+var eqOrdering = new Data_Eq.Eq(function (v) {+ return function (v1) {+ if (v instanceof LT && v1 instanceof LT) {+ return true;+ };+ if (v instanceof GT && v1 instanceof GT) {+ return true;+ };+ if (v instanceof EQ && v1 instanceof EQ) {+ return true;+ };+ return false;+ };+});+module.exports = {+ LT: LT, + GT: GT, + EQ: EQ, + invert: invert, + eqOrdering: eqOrdering, + semigroupOrdering: semigroupOrdering, + showOrdering: showOrdering+};++},{"../Data.Eq":138,"../Data.Semigroup":229,"../Data.Show":233}],218:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Either = require("../Data.Either");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Profunctor = require("../Data.Profunctor");+var Prelude = require("../Prelude");+var Choice = function (Profunctor0, left, right) {+ this.Profunctor0 = Profunctor0;+ this.left = left;+ this.right = right;+};+var right = function (dict) {+ return dict.right;+};+var left = function (dict) {+ return dict.left;+};+var splitChoice = function (dictCategory) {+ return function (dictChoice) {+ return function (l) {+ return function (r) {+ return Control_Semigroupoid.composeFlipped(dictCategory.Semigroupoid0())(left(dictChoice)(l))(right(dictChoice)(r));+ };+ };+ };+};+var fanin = function (dictCategory) {+ return function (dictChoice) {+ return function (l) {+ return function (r) {+ var join = Data_Profunctor.dimap(dictChoice.Profunctor0())(Data_Either.either(Control_Category.id(Control_Category.categoryFn))(Control_Category.id(Control_Category.categoryFn)))(Control_Category.id(Control_Category.categoryFn))(Control_Category.id(dictCategory));+ return Control_Semigroupoid.composeFlipped(dictCategory.Semigroupoid0())(splitChoice(dictCategory)(dictChoice)(l)(r))(join);+ };+ };+ };+};+var choiceFn = new Choice(function () {+ return Data_Profunctor.profunctorFn;+}, function (v) {+ return function (v1) {+ if (v1 instanceof Data_Either.Left) {+ return Data_Either.Left.create(v(v1.value0));+ };+ if (v1 instanceof Data_Either.Right) {+ return new Data_Either.Right(v1.value0);+ };+ throw new Error("Failed pattern match at Data.Profunctor.Choice line 33, column 3 - line 33, column 36: " + [ v.constructor.name, v1.constructor.name ]);+ };+}, Data_Functor.map(Data_Either.functorEither));+module.exports = {+ Choice: Choice, + fanin: fanin, + left: left, + right: right, + splitChoice: splitChoice, + choiceFn: choiceFn+};++},{"../Control.Category":47,"../Control.Semigroupoid":92,"../Data.Either":136,"../Data.Function":149,"../Data.Functor":155,"../Data.Profunctor":225,"../Prelude":268}],219:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Profunctor = require("../Data.Profunctor");+var Prelude = require("../Prelude");+var Closed = function (Profunctor0, closed) {+ this.Profunctor0 = Profunctor0;+ this.closed = closed;+};+var closedFunction = new Closed(function () {+ return Data_Profunctor.profunctorFn;+}, Control_Semigroupoid.compose(Control_Semigroupoid.semigroupoidFn));+var closed = function (dict) {+ return dict.closed;+};+module.exports = {+ Closed: Closed, + closed: closed, + closedFunction: closedFunction+};++},{"../Control.Semigroupoid":92,"../Data.Profunctor":225,"../Prelude":268}],220:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Either = require("../Data.Either");+var Data_Profunctor = require("../Data.Profunctor");+var Cochoice = function (Profunctor0, unleft, unright) {+ this.Profunctor0 = Profunctor0;+ this.unleft = unleft;+ this.unright = unright;+};+var unright = function (dict) {+ return dict.unright;+};+var unleft = function (dict) {+ return dict.unleft;+};+module.exports = {+ Cochoice: Cochoice, + unleft: unleft, + unright: unright+};++},{"../Data.Either":136,"../Data.Profunctor":225}],221:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Category = require("../Control.Category");+var Control_Comonad = require("../Control.Comonad");+var Control_Extend = require("../Control.Extend");+var Control_Monad = require("../Control.Monad");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Distributive = require("../Data.Distributive");+var Data_Either = require("../Data.Either");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Functor_Invariant = require("../Data.Functor.Invariant");+var Data_Newtype = require("../Data.Newtype");+var Data_Profunctor = require("../Data.Profunctor");+var Data_Profunctor_Closed = require("../Data.Profunctor.Closed");+var Data_Profunctor_Cochoice = require("../Data.Profunctor.Cochoice");+var Data_Profunctor_Costrong = require("../Data.Profunctor.Costrong");+var Data_Profunctor_Strong = require("../Data.Profunctor.Strong");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var Costar = function (x) {+ return x;+};+var semigroupoidCostar = function (dictExtend) {+ return new Control_Semigroupoid.Semigroupoid(function (v) {+ return function (v1) {+ return Control_Extend.composeCoKleisliFlipped(dictExtend)(v)(v1);+ };+ });+};+var profunctorCostar = function (dictFunctor) {+ return new Data_Profunctor.Profunctor(function (f) {+ return function (g) {+ return function (v) {+ return function ($51) {+ return g(v(Data_Functor.map(dictFunctor)(f)($51)));+ };+ };+ };+ });+};+var strongCostar = function (dictComonad) {+ return new Data_Profunctor_Strong.Strong(function () {+ return profunctorCostar((dictComonad.Extend0()).Functor0());+ }, function (v) {+ return function (x) {+ return new Data_Tuple.Tuple(v(Data_Functor.map((dictComonad.Extend0()).Functor0())(Data_Tuple.fst)(x)), Data_Tuple.snd(Control_Comonad.extract(dictComonad)(x)));+ };+ }, function (v) {+ return function (x) {+ return new Data_Tuple.Tuple(Data_Tuple.fst(Control_Comonad.extract(dictComonad)(x)), v(Data_Functor.map((dictComonad.Extend0()).Functor0())(Data_Tuple.snd)(x)));+ };+ });+};+var newtypeCostar = new Data_Newtype.Newtype(function (n) {+ return n;+}, Costar);+var functorCostar = new Data_Functor.Functor(function (f) {+ return function (v) {+ return function ($52) {+ return f(v($52));+ };+ };+});+var invariantCostar = new Data_Functor_Invariant.Invariant(Data_Functor_Invariant.imapF(functorCostar));+var distributiveCostar = new Data_Distributive.Distributive(function () {+ return functorCostar;+}, function (dictFunctor) {+ return function (f) {+ return function ($53) {+ return Data_Distributive.distribute(distributiveCostar)(dictFunctor)(Data_Functor.map(dictFunctor)(f)($53));+ };+ };+}, function (dictFunctor) {+ return function (f) {+ return function (a) {+ return Data_Functor.map(dictFunctor)(function (v) {+ return v(a);+ })(f);+ };+ };+});+var costrongCostar = function (dictFunctor) {+ return new Data_Profunctor_Costrong.Costrong(function () {+ return profunctorCostar(dictFunctor);+ }, function (v) {+ return function (fb) {+ var bd = v(Data_Functor.map(dictFunctor)(function (a) {+ return new Data_Tuple.Tuple(a, Data_Tuple.snd(bd));+ })(fb));+ return Data_Tuple.fst(bd);+ };+ }, function (v) {+ return function (fb) {+ var db = v(Data_Functor.map(dictFunctor)(function (a) {+ return new Data_Tuple.Tuple(Data_Tuple.fst(db), a);+ })(fb));+ return Data_Tuple.snd(db);+ };+ });+};+var cochoiceCostar = function (dictApplicative) {+ return new Data_Profunctor_Cochoice.Cochoice(function () {+ return profunctorCostar((dictApplicative.Apply0()).Functor0());+ }, function (v) {+ var g = function ($54) {+ return Data_Either.either(Control_Category.id(Control_Category.categoryFn))(function (r) {+ return g(Control_Applicative.pure(dictApplicative)(new Data_Either.Right(r)));+ })(v($54));+ };+ return function ($55) {+ return g(Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Either.Left.create)($55));+ };+ }, function (v) {+ var g = function ($56) {+ return Data_Either.either(function (l) {+ return g(Control_Applicative.pure(dictApplicative)(new Data_Either.Left(l)));+ })(Control_Category.id(Control_Category.categoryFn))(v($56));+ };+ return function ($57) {+ return g(Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Either.Right.create)($57));+ };+ });+};+var closedCostar = function (dictFunctor) {+ return new Data_Profunctor_Closed.Closed(function () {+ return profunctorCostar(dictFunctor);+ }, function (v) {+ return function (g) {+ return function (x) {+ return v(Data_Functor.map(dictFunctor)(function (v1) {+ return v1(x);+ })(g));+ };+ };+ });+};+var categoryCostar = function (dictComonad) {+ return new Control_Category.Category(function () {+ return semigroupoidCostar(dictComonad.Extend0());+ }, Control_Comonad.extract(dictComonad));+};+var applyCostar = new Control_Apply.Apply(function () {+ return functorCostar;+}, function (v) {+ return function (v1) {+ return function (a) {+ return v(a)(v1(a));+ };+ };+});+var bindCostar = new Control_Bind.Bind(function () {+ return applyCostar;+}, function (v) {+ return function (f) {+ return function (x) {+ var v1 = f(v(x));+ return v1(x);+ };+ };+});+var applicativeCostar = new Control_Applicative.Applicative(function () {+ return applyCostar;+}, function (a) {+ return function (v) {+ return a;+ };+});+var monadCostar = new Control_Monad.Monad(function () {+ return applicativeCostar;+}, function () {+ return bindCostar;+});+module.exports = {+ Costar: Costar, + newtypeCostar: newtypeCostar, + semigroupoidCostar: semigroupoidCostar, + categoryCostar: categoryCostar, + functorCostar: functorCostar, + invariantCostar: invariantCostar, + applyCostar: applyCostar, + applicativeCostar: applicativeCostar, + bindCostar: bindCostar, + monadCostar: monadCostar, + distributiveCostar: distributiveCostar, + profunctorCostar: profunctorCostar, + strongCostar: strongCostar, + costrongCostar: costrongCostar, + cochoiceCostar: cochoiceCostar, + closedCostar: closedCostar+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Category":47,"../Control.Comonad":48,"../Control.Extend":49,"../Control.Monad":86,"../Control.Semigroupoid":92,"../Data.Distributive":135,"../Data.Either":136,"../Data.Function":149,"../Data.Functor":155,"../Data.Functor.Invariant":153,"../Data.Newtype":209,"../Data.Profunctor":225,"../Data.Profunctor.Closed":219,"../Data.Profunctor.Cochoice":220,"../Data.Profunctor.Costrong":222,"../Data.Profunctor.Strong":224,"../Data.Tuple":245,"../Prelude":268}],222:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Profunctor = require("../Data.Profunctor");+var Data_Tuple = require("../Data.Tuple");+var Costrong = function (Profunctor0, unfirst, unsecond) {+ this.Profunctor0 = Profunctor0;+ this.unfirst = unfirst;+ this.unsecond = unsecond;+};+var unsecond = function (dict) {+ return dict.unsecond;+};+var unfirst = function (dict) {+ return dict.unfirst;+};+module.exports = {+ Costrong: Costrong, + unfirst: unfirst, + unsecond: unsecond+};++},{"../Data.Profunctor":225,"../Data.Tuple":245}],223:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Alt = require("../Control.Alt");+var Control_Alternative = require("../Control.Alternative");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Category = require("../Control.Category");+var Control_Monad = require("../Control.Monad");+var Control_MonadPlus = require("../Control.MonadPlus");+var Control_MonadZero = require("../Control.MonadZero");+var Control_Plus = require("../Control.Plus");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Distributive = require("../Data.Distributive");+var Data_Either = require("../Data.Either");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Functor_Invariant = require("../Data.Functor.Invariant");+var Data_Newtype = require("../Data.Newtype");+var Data_Profunctor = require("../Data.Profunctor");+var Data_Profunctor_Choice = require("../Data.Profunctor.Choice");+var Data_Profunctor_Closed = require("../Data.Profunctor.Closed");+var Data_Profunctor_Strong = require("../Data.Profunctor.Strong");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var Star = function (x) {+ return x;+};+var semigroupoidStar = function (dictBind) {+ return new Control_Semigroupoid.Semigroupoid(function (v) {+ return function (v1) {+ return function (x) {+ return Control_Bind.bind(dictBind)(v1(x))(v);+ };+ };+ });+};+var profunctorStar = function (dictFunctor) {+ return new Data_Profunctor.Profunctor(function (f) {+ return function (g) {+ return function (v) {+ return function ($75) {+ return Data_Functor.map(dictFunctor)(g)(v(f($75)));+ };+ };+ };+ });+};+var strongStar = function (dictFunctor) {+ return new Data_Profunctor_Strong.Strong(function () {+ return profunctorStar(dictFunctor);+ }, function (v) {+ return function (v1) {+ return Data_Functor.map(dictFunctor)(function (v2) {+ return new Data_Tuple.Tuple(v2, v1.value1);+ })(v(v1.value0));+ };+ }, function (v) {+ return function (v1) {+ return Data_Functor.map(dictFunctor)(Data_Tuple.Tuple.create(v1.value0))(v(v1.value1));+ };+ });+};+var newtypeStar = new Data_Newtype.Newtype(function (n) {+ return n;+}, Star);+var invariantStar = function (dictInvariant) {+ return new Data_Functor_Invariant.Invariant(function (f) {+ return function (g) {+ return function (v) {+ return function ($76) {+ return Data_Functor_Invariant.imap(dictInvariant)(f)(g)(v($76));+ };+ };+ };+ });+};+var functorStar = function (dictFunctor) {+ return new Data_Functor.Functor(function (f) {+ return function (v) {+ return function ($77) {+ return Data_Functor.map(dictFunctor)(f)(v($77));+ };+ };+ });+};+var distributiveStar = function (dictDistributive) {+ return new Data_Distributive.Distributive(function () {+ return functorStar(dictDistributive.Functor0());+ }, function (dictFunctor) {+ return function (f) {+ return function ($78) {+ return Data_Distributive.distribute(distributiveStar(dictDistributive))(dictFunctor)(Data_Functor.map(dictFunctor)(f)($78));+ };+ };+ }, function (dictFunctor) {+ return function (f) {+ return function (a) {+ return Data_Distributive.collect(dictDistributive)(dictFunctor)(function (v) {+ return v(a);+ })(f);+ };+ };+ });+};+var closedStar = function (dictDistributive) {+ return new Data_Profunctor_Closed.Closed(function () {+ return profunctorStar(dictDistributive.Functor0());+ }, function (v) {+ return function (g) {+ return Data_Distributive.distribute(dictDistributive)(Data_Functor.functorFn)(function ($79) {+ return v(g($79));+ });+ };+ });+};+var choiceStar = function (dictApplicative) {+ return new Data_Profunctor_Choice.Choice(function () {+ return profunctorStar((dictApplicative.Apply0()).Functor0());+ }, function (v) {+ return Star(Data_Either.either(function ($80) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Either.Left.create)(v($80));+ })(function ($81) {+ return Control_Applicative.pure(dictApplicative)(Data_Either.Right.create($81));+ }));+ }, function (v) {+ return Star(Data_Either.either(function ($82) {+ return Control_Applicative.pure(dictApplicative)(Data_Either.Left.create($82));+ })(function ($83) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Either.Right.create)(v($83));+ }));+ });+};+var categoryStar = function (dictMonad) {+ return new Control_Category.Category(function () {+ return semigroupoidStar(dictMonad.Bind1());+ }, Control_Applicative.pure(dictMonad.Applicative0()));+};+var applyStar = function (dictApply) {+ return new Control_Apply.Apply(function () {+ return functorStar(dictApply.Functor0());+ }, function (v) {+ return function (v1) {+ return function (a) {+ return Control_Apply.apply(dictApply)(v(a))(v1(a));+ };+ };+ });+};+var bindStar = function (dictBind) {+ return new Control_Bind.Bind(function () {+ return applyStar(dictBind.Apply0());+ }, function (v) {+ return function (f) {+ return function (x) {+ return Control_Bind.bind(dictBind)(v(x))(function (a) {+ var v1 = f(a);+ return v1(x);+ });+ };+ };+ });+};+var applicativeStar = function (dictApplicative) {+ return new Control_Applicative.Applicative(function () {+ return applyStar(dictApplicative.Apply0());+ }, function (a) {+ return function (v) {+ return Control_Applicative.pure(dictApplicative)(a);+ };+ });+};+var monadStar = function (dictMonad) {+ return new Control_Monad.Monad(function () {+ return applicativeStar(dictMonad.Applicative0());+ }, function () {+ return bindStar(dictMonad.Bind1());+ });+};+var altStar = function (dictAlt) {+ return new Control_Alt.Alt(function () {+ return functorStar(dictAlt.Functor0());+ }, function (v) {+ return function (v1) {+ return function (a) {+ return Control_Alt.alt(dictAlt)(v(a))(v1(a));+ };+ };+ });+};+var plusStar = function (dictPlus) {+ return new Control_Plus.Plus(function () {+ return altStar(dictPlus.Alt0());+ }, function (v) {+ return Control_Plus.empty(dictPlus);+ });+};+var alternativeStar = function (dictAlternative) {+ return new Control_Alternative.Alternative(function () {+ return applicativeStar(dictAlternative.Applicative0());+ }, function () {+ return plusStar(dictAlternative.Plus1());+ });+};+var monadZeroStar = function (dictMonadZero) {+ return new Control_MonadZero.MonadZero(function () {+ return alternativeStar(dictMonadZero.Alternative1());+ }, function () {+ return monadStar(dictMonadZero.Monad0());+ });+};+var monadPlusStar = function (dictMonadPlus) {+ return new Control_MonadPlus.MonadPlus(function () {+ return monadZeroStar(dictMonadPlus.MonadZero0());+ });+};+module.exports = {+ Star: Star, + newtypeStar: newtypeStar, + semigroupoidStar: semigroupoidStar, + categoryStar: categoryStar, + functorStar: functorStar, + invariantStar: invariantStar, + applyStar: applyStar, + applicativeStar: applicativeStar, + bindStar: bindStar, + monadStar: monadStar, + altStar: altStar, + plusStar: plusStar, + alternativeStar: alternativeStar, + monadZeroStar: monadZeroStar, + monadPlusStar: monadPlusStar, + distributiveStar: distributiveStar, + profunctorStar: profunctorStar, + strongStar: strongStar, + choiceStar: choiceStar, + closedStar: closedStar+};++},{"../Control.Alt":38,"../Control.Alternative":39,"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Category":47,"../Control.Monad":86,"../Control.MonadPlus":87,"../Control.MonadZero":88,"../Control.Plus":91,"../Control.Semigroupoid":92,"../Data.Distributive":135,"../Data.Either":136,"../Data.Function":149,"../Data.Functor":155,"../Data.Functor.Invariant":153,"../Data.Newtype":209,"../Data.Profunctor":225,"../Data.Profunctor.Choice":218,"../Data.Profunctor.Closed":219,"../Data.Profunctor.Strong":224,"../Data.Tuple":245,"../Prelude":268}],224:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Functor = require("../Data.Functor");+var Data_Profunctor = require("../Data.Profunctor");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var Strong = function (Profunctor0, first, second) {+ this.Profunctor0 = Profunctor0;+ this.first = first;+ this.second = second;+};+var strongFn = new Strong(function () {+ return Data_Profunctor.profunctorFn;+}, function (a2b) {+ return function (v) {+ return new Data_Tuple.Tuple(a2b(v.value0), v.value1);+ };+}, Data_Functor.map(Data_Tuple.functorTuple));+var second = function (dict) {+ return dict.second;+};+var first = function (dict) {+ return dict.first;+};+var splitStrong = function (dictCategory) {+ return function (dictStrong) {+ return function (l) {+ return function (r) {+ return Control_Semigroupoid.composeFlipped(dictCategory.Semigroupoid0())(first(dictStrong)(l))(second(dictStrong)(r));+ };+ };+ };+};+var fanout = function (dictCategory) {+ return function (dictStrong) {+ return function (l) {+ return function (r) {+ var split = Data_Profunctor.dimap(dictStrong.Profunctor0())(Control_Category.id(Control_Category.categoryFn))(function (a) {+ return new Data_Tuple.Tuple(a, a);+ })(Control_Category.id(dictCategory));+ return Control_Semigroupoid.composeFlipped(dictCategory.Semigroupoid0())(split)(splitStrong(dictCategory)(dictStrong)(l)(r));+ };+ };+ };+};+module.exports = {+ Strong: Strong, + fanout: fanout, + first: first, + second: second, + splitStrong: splitStrong, + strongFn: strongFn+};++},{"../Control.Category":47,"../Control.Semigroupoid":92,"../Data.Functor":155,"../Data.Profunctor":225,"../Data.Tuple":245,"../Prelude":268}],225:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Category = require("../Control.Category");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Newtype = require("../Data.Newtype");+var Prelude = require("../Prelude");+var Profunctor = function (dimap) {+ this.dimap = dimap;+};+var profunctorFn = new Profunctor(function (a2b) {+ return function (c2d) {+ return function (b2c) {+ return function ($9) {+ return c2d(b2c(a2b($9)));+ };+ };+ };+});+var dimap = function (dict) {+ return dict.dimap;+};+var lmap = function (dictProfunctor) {+ return function (a2b) {+ return dimap(dictProfunctor)(a2b)(Control_Category.id(Control_Category.categoryFn));+ };+};+var rmap = function (dictProfunctor) {+ return function (b2c) {+ return dimap(dictProfunctor)(Control_Category.id(Control_Category.categoryFn))(b2c);+ };+};+var unwrapIso = function (dictProfunctor) {+ return function (dictNewtype) {+ return dimap(dictProfunctor)(Data_Newtype.wrap(dictNewtype))(Data_Newtype.unwrap(dictNewtype));+ };+};+var wrapIso = function (dictProfunctor) {+ return function (dictNewtype) {+ return function (v) {+ return dimap(dictProfunctor)(Data_Newtype.unwrap(dictNewtype))(Data_Newtype.wrap(dictNewtype));+ };+ };+};+var arr = function (dictCategory) {+ return function (dictProfunctor) {+ return function (f) {+ return rmap(dictProfunctor)(f)(Control_Category.id(dictCategory));+ };+ };+};+module.exports = {+ Profunctor: Profunctor, + arr: arr, + dimap: dimap, + lmap: lmap, + rmap: rmap, + unwrapIso: unwrapIso, + wrapIso: wrapIso, + profunctorFn: profunctorFn+};++},{"../Control.Category":47,"../Control.Semigroupoid":92,"../Data.Newtype":209,"../Prelude":268}],226:[function(require,module,exports){+"use strict";++exports.intSub = function (x) {+ return function (y) {+ /* jshint bitwise: false */+ return x - y | 0;+ };+};++exports.numSub = function (n1) {+ return function (n2) {+ return n1 - n2;+ };+};++},{}],227:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Data_Semiring = require("../Data.Semiring");+var Data_Unit = require("../Data.Unit");+var Ring = function (Semiring0, sub) {+ this.Semiring0 = Semiring0;+ this.sub = sub;+};+var sub = function (dict) {+ return dict.sub;+};+var ringUnit = new Ring(function () {+ return Data_Semiring.semiringUnit;+}, function (v) {+ return function (v1) {+ return Data_Unit.unit;+ };+});+var ringNumber = new Ring(function () {+ return Data_Semiring.semiringNumber;+}, $foreign.numSub);+var ringInt = new Ring(function () {+ return Data_Semiring.semiringInt;+}, $foreign.intSub);+var ringFn = function (dictRing) {+ return new Ring(function () {+ return Data_Semiring.semiringFn(dictRing.Semiring0());+ }, function (f) {+ return function (g) {+ return function (x) {+ return sub(dictRing)(f(x))(g(x));+ };+ };+ });+};+var negate = function (dictRing) {+ return function (a) {+ return sub(dictRing)(Data_Semiring.zero(dictRing.Semiring0()))(a);+ };+};+module.exports = {+ Ring: Ring, + negate: negate, + sub: sub, + ringInt: ringInt, + ringNumber: ringNumber, + ringUnit: ringUnit, + ringFn: ringFn+};++},{"../Data.Semiring":231,"../Data.Unit":249,"./foreign":226}],228:[function(require,module,exports){+"use strict";++exports.concatString = function (s1) {+ return function (s2) {+ return s1 + s2;+ };+};++exports.concatArray = function (xs) {+ return function (ys) {+ if (xs.length === 0) return ys;+ if (ys.length === 0) return xs;+ return xs.concat(ys);+ };+};++},{}],229:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Data_Unit = require("../Data.Unit");+var Data_Void = require("../Data.Void");+var Semigroup = function (append) {+ this.append = append;+};+var semigroupVoid = new Semigroup(function (v) {+ return Data_Void.absurd;+});+var semigroupUnit = new Semigroup(function (v) {+ return function (v1) {+ return Data_Unit.unit;+ };+});+var semigroupString = new Semigroup($foreign.concatString);+var semigroupArray = new Semigroup($foreign.concatArray);+var append = function (dict) {+ return dict.append;+};+var semigroupFn = function (dictSemigroup) {+ return new Semigroup(function (f) {+ return function (g) {+ return function (x) {+ return append(dictSemigroup)(f(x))(g(x));+ };+ };+ });+};+module.exports = {+ Semigroup: Semigroup, + append: append, + semigroupString: semigroupString, + semigroupUnit: semigroupUnit, + semigroupVoid: semigroupVoid, + semigroupFn: semigroupFn, + semigroupArray: semigroupArray+};++},{"../Data.Unit":249,"../Data.Void":250,"./foreign":228}],230:[function(require,module,exports){+"use strict";++exports.intAdd = function (x) {+ return function (y) {+ /* jshint bitwise: false */+ return x + y | 0;+ };+};++exports.intMul = function (x) {+ return function (y) {+ /* jshint bitwise: false */+ return x * y | 0;+ };+};++exports.numAdd = function (n1) {+ return function (n2) {+ return n1 + n2;+ };+};++exports.numMul = function (n1) {+ return function (n2) {+ return n1 * n2;+ };+};++},{}],231:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Data_Unit = require("../Data.Unit");+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 semiringUnit = new Semiring(function (v) {+ return function (v1) {+ return Data_Unit.unit;+ };+}, function (v) {+ return function (v1) {+ return Data_Unit.unit;+ };+}, Data_Unit.unit, Data_Unit.unit);+var semiringNumber = new Semiring($foreign.numAdd, $foreign.numMul, 1.0, 0.0);+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;+};+var semiringFn = function (dictSemiring) {+ return new Semiring(function (f) {+ return function (g) {+ return function (x) {+ return add(dictSemiring)(f(x))(g(x));+ };+ };+ }, function (f) {+ return function (g) {+ return function (x) {+ return mul(dictSemiring)(f(x))(g(x));+ };+ };+ }, function (v) {+ return one(dictSemiring);+ }, function (v) {+ return zero(dictSemiring);+ });+};+module.exports = {+ Semiring: Semiring, + add: add, + mul: mul, + one: one, + zero: zero, + semiringInt: semiringInt, + semiringNumber: semiringNumber, + semiringFn: semiringFn, + semiringUnit: semiringUnit+};++},{"../Data.Unit":249,"./foreign":230}],232:[function(require,module,exports){+"use strict";++exports.showIntImpl = function (n) {+ return n.toString();+};++exports.showNumberImpl = function (n) {+ var str = n.toString();+ return isNaN(str + ".0") ? str : str + ".0";+};++exports.showCharImpl = function (c) {+ var code = c.charCodeAt(0);+ if (code < 0x20 || code === 0x7F) {+ switch (c) {+ case "\x07": return "'\\a'";+ case "\b": return "'\\b'";+ case "\f": return "'\\f'";+ case "\n": return "'\\n'";+ case "\r": return "'\\r'";+ case "\t": return "'\\t'";+ case "\v": return "'\\v'";+ }+ return "'\\" + code.toString(10) + "'";+ }+ return c === "'" || c === "\\" ? "'\\" + c + "'" : "'" + c + "'";+};++exports.showStringImpl = function (s) {+ var l = s.length;+ return "\"" + s.replace(+ /[\0-\x1F\x7F"\\]/g, // eslint-disable-line no-control-regex+ function (c, i) {+ switch (c) {+ case "\"":+ case "\\":+ return "\\" + c;+ case "\x07": return "\\a";+ case "\b": return "\\b";+ case "\f": return "\\f";+ case "\n": return "\\n";+ case "\r": return "\\r";+ case "\t": return "\\t";+ case "\v": return "\\v";+ }+ var k = i + 1;+ var empty = k < l && s[k] >= "0" && s[k] <= "9" ? "\\&" : "";+ return "\\" + c.charCodeAt(0).toString(10) + empty;+ }+ ) + "\"";+};++exports.showArrayImpl = function (f) {+ return function (xs) {+ var ss = [];+ for (var i = 0, l = xs.length; i < l; i++) {+ ss[i] = f(xs[i]);+ }+ return "[" + ss.join(",") + "]";+ };+};++},{}],233:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Show = function (show) {+ this.show = show;+};+var showString = new Show($foreign.showStringImpl);+var showNumber = new Show($foreign.showNumberImpl);+var showInt = new Show($foreign.showIntImpl);+var showChar = new Show($foreign.showCharImpl);+var showBoolean = new Show(function (v) {+ if (v) {+ return "true";+ };+ if (!v) {+ return "false";+ };+ throw new Error("Failed pattern match at Data.Show line 13, column 3 - line 14, column 3: " + [ v.constructor.name ]);+});+var show = function (dict) {+ return dict.show;+};+var showArray = function (dictShow) {+ return new Show($foreign.showArrayImpl(show(dictShow)));+};+module.exports = {+ Show: Show, + show: show, + showBoolean: showBoolean, + showInt: showInt, + showNumber: showNumber, + showChar: showChar, + showString: showString, + showArray: showArray+};++},{"./foreign":232}],234:[function(require,module,exports){+"use strict";++exports["new"] = function () {+ return {};+};++exports.peekImpl = function (just) {+ return function (nothing) {+ return function (m) {+ return function (k) {+ return function () {+ return {}.hasOwnProperty.call(m, k) ? just(m[k]) : nothing;+ };+ };+ };+ };+};++exports.poke = function (m) {+ return function (k) {+ return function (v) {+ return function () {+ m[k] = v;+ return m;+ };+ };+ };+};++exports["delete"] = function (m) {+ return function (k) {+ return function () {+ delete m[k];+ return m;+ };+ };+};++},{}],235:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var Control_Monad_ST = require("../Control.Monad.ST");+var Data_Maybe = require("../Data.Maybe");+var peek = $foreign.peekImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+module.exports = {+ peek: peek, + "delete": $foreign["delete"], + "new": $foreign["new"], + poke: $foreign.poke+};++},{"../Control.Monad.Eff":70,"../Control.Monad.ST":79,"../Data.Maybe":198,"./foreign":234}],236:[function(require,module,exports){+"use strict";++exports._copyEff = function (m) {+ return function () {+ var r = {};+ for (var k in m) {+ if (hasOwnProperty.call(m, k)) {+ r[k] = m[k];+ }+ }+ return r;+ };+};++exports.empty = {};++exports.runST = function (f) {+ return f;+};++exports._fmapStrMap = function (m0, f) {+ var m = {};+ for (var k in m0) {+ if (hasOwnProperty.call(m0, k)) {+ m[k] = f(m0[k]);+ }+ }+ return m;+};++exports._mapWithKey = function (m0, f) {+ var m = {};+ for (var k in m0) {+ if (hasOwnProperty.call(m0, k)) {+ m[k] = f(k)(m0[k]);+ }+ }+ return m;+};++exports._foldM = function (bind) {+ return function (f) {+ return function (mz) {+ return function (m) {+ var acc = mz;+ function g(k) {+ return function (z) {+ return f(z)(k)(m[k]);+ };+ }+ for (var k in m) {+ if (hasOwnProperty.call(m, k)) {+ acc = bind(acc)(g(k));+ }+ }+ return acc;+ };+ };+ };+};++exports._foldSCStrMap = function (m, z, f, fromMaybe) {+ var acc = z;+ for (var k in m) {+ if (hasOwnProperty.call(m, k)) {+ var maybeR = f(acc)(k)(m[k]);+ var r = fromMaybe(null)(maybeR);+ if (r === null) return acc;+ else acc = r;+ }+ }+ return acc;+};++exports.all = function (f) {+ return function (m) {+ for (var k in m) {+ if (hasOwnProperty.call(m, k) && !f(k)(m[k])) return false;+ }+ return true;+ };+};++exports.size = function (m) {+ var s = 0;+ for (var k in m) {+ if (hasOwnProperty.call(m, k)) {+ ++s;+ }+ }+ return s;+};++exports._lookup = function (no, yes, k, m) {+ return k in m ? yes(m[k]) : no;+};++exports._unsafeDeleteStrMap = function (m, k) {+ delete m[k];+ return m;+};++exports._lookupST = function (no, yes, k, m) {+ return function () {+ return k in m ? yes(m[k]) : no;+ };+};++function _collect(f) {+ return function (m) {+ var r = [];+ for (var k in m) {+ if (hasOwnProperty.call(m, k)) {+ r.push(f(k)(m[k]));+ }+ }+ return r;+ };+}++exports._collect = _collect;++exports.keys = Object.keys || _collect(function (k) {+ return function () { return k; };+});++},{}],237:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Category = require("../Control.Category");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var Control_Monad_ST = require("../Control.Monad.ST");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Array = require("../Data.Array");+var Data_Eq = require("../Data.Eq");+var Data_Foldable = require("../Data.Foldable");+var Data_Function = require("../Data.Function");+var Data_Function_Uncurried = require("../Data.Function.Uncurried");+var Data_Functor = require("../Data.Functor");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Maybe = require("../Data.Maybe");+var Data_Monoid = require("../Data.Monoid");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Data_StrMap_ST = require("../Data.StrMap.ST");+var Data_Traversable = require("../Data.Traversable");+var Data_Tuple = require("../Data.Tuple");+var Data_Unfoldable = require("../Data.Unfoldable");+var Prelude = require("../Prelude");+var values = $foreign._collect(function (v) {+ return function (v1) {+ return v1;+ };+});+var toUnfoldable = function (dictUnfoldable) {+ return function ($40) {+ return Data_Array.toUnfoldable(dictUnfoldable)($foreign._collect(Data_Tuple.Tuple.create)($40));+ };+};+var toArray = $foreign._collect(Data_Tuple.Tuple.create);+var thawST = $foreign._copyEff;+var showStrMap = function (dictShow) {+ return new Data_Show.Show(function (m) {+ return "(fromFoldable " + (Data_Show.show(Data_Show.showArray(Data_Tuple.showTuple(Data_Show.showString)(dictShow)))(toArray(m)) + ")");+ });+};+var pureST = function (f) {+ return Control_Monad_Eff.runPure($foreign.runST(f));+};+var singleton = function (k) {+ return function (v) {+ return pureST(function __do() {+ var v1 = Data_StrMap_ST["new"]();+ var v2 = Data_StrMap_ST.poke(v1)(k)(v)();+ return v1;+ });+ };+};+var mutate = function (f) {+ return function (m) {+ return pureST(function __do() {+ var v = thawST(m)();+ var v1 = f(v)();+ return v;+ });+ };+};+var member = Data_Function_Uncurried.runFn4($foreign._lookup)(false)(Data_Function["const"](true));+var mapWithKey = function (f) {+ return function (m) {+ return $foreign._mapWithKey(m, f);+ };+};+var lookup = Data_Function_Uncurried.runFn4($foreign._lookup)(Data_Maybe.Nothing.value)(Data_Maybe.Just.create);+var isSubmap = function (dictEq) {+ return function (m1) {+ return function (m2) {+ var f = function (k) {+ return function (v) {+ return $foreign._lookup(false, Data_Eq.eq(dictEq)(v), k, m2);+ };+ };+ return $foreign.all(f)(m1);+ };+ };+};+var isEmpty = $foreign.all(function (v) {+ return function (v1) {+ return false;+ };+});+var insert = function (k) {+ return function (v) {+ return mutate(function (s) {+ return Data_Functor["void"](Control_Monad_Eff.functorEff)(Data_StrMap_ST.poke(s)(k)(v));+ });+ };+};+var functorStrMap = new Data_Functor.Functor(function (f) {+ return function (m) {+ return $foreign._fmapStrMap(m, f);+ };+});+var fromFoldableWith = function (dictFoldable) {+ return function (f) {+ return function (l) {+ return pureST(function __do() {+ var v = Data_StrMap_ST["new"]();+ Data_Foldable.for_(Control_Monad_Eff.applicativeEff)(dictFoldable)(l)(function (v1) {+ return Control_Bind.bind(Control_Monad_Eff.bindEff)($foreign._lookupST(v1.value1, f(v1.value1), v1.value0, v))(Data_StrMap_ST.poke(v)(v1.value0));+ })();+ return v;+ });+ };+ };+};+var fromFoldable = function (dictFoldable) {+ return function (l) {+ return pureST(function __do() {+ var v = Data_StrMap_ST["new"]();+ Data_Foldable.for_(Control_Monad_Eff.applicativeEff)(dictFoldable)(l)(function (v1) {+ return Data_StrMap_ST.poke(v)(v1.value0)(v1.value1);+ })();+ return v;+ });+ };+};+var freezeST = $foreign._copyEff;+var foldMaybe = function (f) {+ return function (z) {+ return function (m) {+ return $foreign._foldSCStrMap(m, z, f, Data_Maybe.fromMaybe);+ };+ };+};+var foldM = function (dictMonad) {+ return function (f) {+ return function (z) {+ return $foreign._foldM(Control_Bind.bind(dictMonad.Bind1()))(f)(Control_Applicative.pure(dictMonad.Applicative0())(z));+ };+ };+};+var semigroupStrMap = 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 function (k) {+ return function (v2) {+ return Data_StrMap_ST.poke(s2)(k)($foreign._lookup(v2, function (v1) {+ return Data_Semigroup.append(dictSemigroup)(v1)(v2);+ }, k, m2));+ };+ };+ })(s1)(m1));+ })(m2);+ };+ });+};+var monoidStrMap = function (dictSemigroup) {+ return new Data_Monoid.Monoid(function () {+ return semigroupStrMap(dictSemigroup);+ }, $foreign.empty);+};+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));+ });+};+var unions = function (dictFoldable) {+ return Data_Foldable.foldl(dictFoldable)(union)($foreign.empty);+};+var fold = $foreign._foldM(Data_Function.applyFlipped);+var foldMap = function (dictMonoid) {+ return function (f) {+ return fold(function (acc) {+ return function (k) {+ return function (v) {+ return Data_Semigroup.append(dictMonoid.Semigroup0())(acc)(f(k)(v));+ };+ };+ })(Data_Monoid.mempty(dictMonoid));+ };+};+var foldableStrMap = new Data_Foldable.Foldable(function (dictMonoid) {+ return function (f) {+ return foldMap(dictMonoid)(Data_Function["const"](f));+ };+}, function (f) {+ return fold(function (z) {+ return function (v) {+ return f(z);+ };+ });+}, function (f) {+ return function (z) {+ return function (m) {+ return Data_Foldable.foldr(Data_Foldable.foldableArray)(f)(z)(values(m));+ };+ };+});+var traversableStrMap = new Data_Traversable.Traversable(function () {+ return foldableStrMap;+}, function () {+ return functorStrMap;+}, function (dictApplicative) {+ return Data_Traversable.traverse(traversableStrMap)(dictApplicative)(Control_Category.id(Control_Category.categoryFn));+}, function (dictApplicative) {+ return function (f) {+ return function (ms) {+ return Data_Foldable.foldr(Data_Foldable.foldableArray)(function (x) {+ return function (acc) {+ return Control_Apply.apply(dictApplicative.Apply0())(Data_Functor.map((dictApplicative.Apply0()).Functor0())(union)(x))(acc);+ };+ })(Control_Applicative.pure(dictApplicative)($foreign.empty))(Data_Functor.map(Data_Functor.functorArray)(Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Tuple.uncurry(singleton)))(Data_Functor.map(Data_Functor.functorArray)(Data_Traversable.traverse(Data_Tuple.traversableTuple)(dictApplicative)(f))(toArray(ms))));+ };+ };+});+var eqStrMap = function (dictEq) {+ return new Data_Eq.Eq(function (m1) {+ return function (m2) {+ return isSubmap(dictEq)(m1)(m2) && isSubmap(dictEq)(m2)(m1);+ };+ });+};+var eq1StrMap = new Data_Eq.Eq1(function (dictEq) {+ return Data_Eq.eq(eqStrMap(dictEq));+});+var $$delete = function (k) {+ return mutate(function (s) {+ return Data_Functor["void"](Control_Monad_Eff.functorEff)(Data_StrMap_ST["delete"](s)(k));+ });+};+var pop = function (k) {+ return function (m) {+ return Data_Functor.mapFlipped(Data_Maybe.functorMaybe)(lookup(k)(m))(function (a) {+ return new Data_Tuple.Tuple(a, $$delete(k)(m));+ });+ };+};+var alter = function (f) {+ return function (k) {+ return function (m) {+ var v = f(lookup(k)(m));+ if (v instanceof Data_Maybe.Nothing) {+ return $$delete(k)(m);+ };+ if (v instanceof Data_Maybe.Just) {+ return insert(k)(v.value0)(m);+ };+ throw new Error("Failed pattern match at Data.StrMap line 187, column 15 - line 189, column 25: " + [ v.constructor.name ]);+ };+ };+};+var update = function (f) {+ return function (k) {+ return function (m) {+ return alter(Data_Maybe.maybe(Data_Maybe.Nothing.value)(f))(k)(m);+ };+ };+};+module.exports = {+ alter: alter, + "delete": $$delete, + fold: fold, + foldM: foldM, + foldMap: foldMap, + foldMaybe: foldMaybe, + freezeST: freezeST, + fromFoldable: fromFoldable, + fromFoldableWith: fromFoldableWith, + insert: insert, + isEmpty: isEmpty, + isSubmap: isSubmap, + lookup: lookup, + mapWithKey: mapWithKey, + member: member, + pop: pop, + pureST: pureST, + singleton: singleton, + thawST: thawST, + toUnfoldable: toUnfoldable, + union: union, + unions: unions, + update: update, + values: values, + functorStrMap: functorStrMap, + foldableStrMap: foldableStrMap, + traversableStrMap: traversableStrMap, + eqStrMap: eqStrMap, + eq1StrMap: eq1StrMap, + showStrMap: showStrMap, + semigroupStrMap: semigroupStrMap, + monoidStrMap: monoidStrMap, + all: $foreign.all, + empty: $foreign.empty, + keys: $foreign.keys, + runST: $foreign.runST, + size: $foreign.size+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Category":47,"../Control.Monad.Eff":70,"../Control.Monad.ST":79,"../Control.Semigroupoid":92,"../Data.Array":119,"../Data.Eq":138,"../Data.Foldable":143,"../Data.Function":149,"../Data.Function.Uncurried":148,"../Data.Functor":155,"../Data.HeytingAlgebra":160,"../Data.Maybe":198,"../Data.Monoid":207,"../Data.Semigroup":229,"../Data.Show":233,"../Data.StrMap.ST":235,"../Data.Traversable":244,"../Data.Tuple":245,"../Data.Unfoldable":247,"../Prelude":268,"./foreign":236}],238:[function(require,module,exports){+"use strict";++exports.charCodeAt = function (i) {+ return function (s) {+ if (i >= 0 && i < s.length) return s.charCodeAt(i);+ throw new Error("Data.String.Unsafe.charCodeAt: Invalid index.");+ };+};++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.char = function (s) {+ if (s.length === 1) return s.charAt(0);+ throw new Error("Data.String.Unsafe.char: Expected string of length 1.");+};++},{}],239:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+module.exports = {+ "char": $foreign["char"], + charAt: $foreign.charAt, + charCodeAt: $foreign.charCodeAt+};++},{"./foreign":238}],240:[function(require,module,exports){+"use strict";++exports._charAt = function (just) {+ return function (nothing) {+ return function (i) {+ return function (s) {+ return i >= 0 && i < s.length ? just(s.charAt(i)) : nothing;+ };+ };+ };+};++exports.singleton = function (c) {+ return c;+};++exports._charCodeAt = function (just) {+ return function (nothing) {+ return function (i) {+ return function (s) {+ return i >= 0 && i < s.length ? just(s.charCodeAt(i)) : nothing;+ };+ };+ };+};++exports._toChar = function (just) {+ return function (nothing) {+ return function (s) {+ return s.length === 1 ? just(s) : nothing;+ };+ };+};++exports.fromCharArray = function (a) {+ return a.join("");+};++exports._indexOf = function (just) {+ return function (nothing) {+ return function (x) {+ return function (s) {+ var i = s.indexOf(x);+ return i === -1 ? nothing : just(i);+ };+ };+ };+};++exports["_indexOf'"] = function (just) {+ return function (nothing) {+ return function (x) {+ return function (startAt) {+ return function (s) {+ if (startAt < 0 || startAt > s.length) return nothing;+ var i = s.indexOf(x, startAt);+ return i === -1 ? nothing : just(i);+ };+ };+ };+ };+};++exports._lastIndexOf = function (just) {+ return function (nothing) {+ return function (x) {+ return function (s) {+ var i = s.lastIndexOf(x);+ return i === -1 ? nothing : just(i);+ };+ };+ };+};++exports["_lastIndexOf'"] = function (just) {+ return function (nothing) {+ return function (x) {+ return function (startAt) {+ return function (s) {+ if (startAt < 0 || startAt > s.length) return nothing;+ var i = s.lastIndexOf(x, startAt);+ return i === -1 ? nothing : just(i);+ };+ };+ };+ };+};++exports.length = function (s) {+ return s.length;+};++exports._localeCompare = function (lt) {+ return function (eq) {+ return function (gt) {+ return function (s1) {+ return function (s2) {+ var result = s1.localeCompare(s2);+ return result < 0 ? lt : result > 0 ? gt : eq;+ };+ };+ };+ };+};++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.count = function (p) {+ return function (s) {+ var i = 0;+ while (i < s.length && p(s.charAt(i))) i++;+ return i;+ };+};++exports.split = function (sep) {+ return function (s) {+ return s.split(sep);+ };+};++exports._splitAt = function (just) {+ return function (nothing) {+ return function (i) {+ return function (s) {+ return i >= 0 && i < s.length ?+ just({ before: s.substring(0, i), after: s.substring(i) }) :+ nothing;+ };+ };+ };+};++exports.toCharArray = function (s) {+ return s.split("");+};++exports.toLower = function (s) {+ return s.toLowerCase();+};++exports.toUpper = function (s) {+ return s.toUpperCase();+};++exports.trim = function (s) {+ return s.trim();+};++exports.joinWith = function (s) {+ return function (xs) {+ return xs.join(s);+ };+};++},{}],241:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Eq = require("../Data.Eq");+var Data_Function = require("../Data.Function");+var Data_Maybe = require("../Data.Maybe");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Ordering = require("../Data.Ordering");+var Data_Ring = require("../Data.Ring");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Show = require("../Data.Show");+var Data_String_Unsafe = require("../Data.String.Unsafe");+var Prelude = require("../Prelude");+var Replacement = function (x) {+ return x;+};+var Pattern = function (x) {+ return x;+};+var uncons = function (v) {+ if (v === "") {+ return Data_Maybe.Nothing.value;+ };+ return new Data_Maybe.Just({+ head: Data_String_Unsafe.charAt(0)(v), + tail: $foreign.drop(1)(v)+ });+};+var toChar = $foreign._toChar(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+var takeWhile = function (p) {+ return function (s) {+ return $foreign.take($foreign.count(p)(s))(s);+ };+};+var splitAt = $foreign._splitAt(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+var showReplacement = new Data_Show.Show(function (v) {+ return "(Replacement " + (v + ")");+});+var showPattern = new Data_Show.Show(function (v) {+ return "(Pattern " + (v + ")");+});+var $$null = function (s) {+ return s === "";+};+var newtypeReplacement = new Data_Newtype.Newtype(function (n) {+ return n;+}, Replacement);+var newtypePattern = new Data_Newtype.Newtype(function (n) {+ return n;+}, Pattern);+var localeCompare = $foreign._localeCompare(Data_Ordering.LT.value)(Data_Ordering.EQ.value)(Data_Ordering.GT.value);+var lastIndexOf$prime = $foreign["_lastIndexOf'"](Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+var lastIndexOf = $foreign._lastIndexOf(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+var stripSuffix = function (v) {+ return function (str) {+ var v1 = lastIndexOf(v)(str);+ if (v1 instanceof Data_Maybe.Just && v1.value0 === ($foreign.length(str) - $foreign.length(v) | 0)) {+ return Data_Maybe.Just.create($foreign.take(v1.value0)(str));+ };+ return Data_Maybe.Nothing.value;+ };+};+var indexOf$prime = $foreign["_indexOf'"](Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+var indexOf = $foreign._indexOf(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+var stripPrefix = function (v) {+ return function (str) {+ var v1 = indexOf(v)(str);+ if (v1 instanceof Data_Maybe.Just && v1.value0 === 0) {+ return Data_Maybe.Just.create($foreign.drop($foreign.length(v))(str));+ };+ return Data_Maybe.Nothing.value;+ };+};+var eqReplacement = new Data_Eq.Eq(function (x) {+ return function (y) {+ return x === y;+ };+});+var ordReplacement = new Data_Ord.Ord(function () {+ return eqReplacement;+}, function (x) {+ return function (y) {+ return Data_Ord.compare(Data_Ord.ordString)(x)(y);+ };+});+var eqPattern = new Data_Eq.Eq(function (x) {+ return function (y) {+ return x === y;+ };+});+var ordPattern = new Data_Ord.Ord(function () {+ return eqPattern;+}, function (x) {+ return function (y) {+ return Data_Ord.compare(Data_Ord.ordString)(x)(y);+ };+});+var dropWhile = function (p) {+ return function (s) {+ return $foreign.drop($foreign.count(p)(s))(s);+ };+};+var contains = function (pat) {+ return function ($48) {+ return Data_Maybe.isJust(indexOf(pat)($48));+ };+};+var charCodeAt = $foreign._charCodeAt(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+var charAt = $foreign._charAt(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);+module.exports = {+ Pattern: Pattern, + Replacement: Replacement, + charAt: charAt, + charCodeAt: charCodeAt, + contains: contains, + dropWhile: dropWhile, + indexOf: indexOf, + "indexOf'": indexOf$prime, + lastIndexOf: lastIndexOf, + "lastIndexOf'": lastIndexOf$prime, + localeCompare: localeCompare, + "null": $$null, + splitAt: splitAt, + stripPrefix: stripPrefix, + stripSuffix: stripSuffix, + takeWhile: takeWhile, + toChar: toChar, + uncons: uncons, + eqPattern: eqPattern, + ordPattern: ordPattern, + newtypePattern: newtypePattern, + showPattern: showPattern, + eqReplacement: eqReplacement, + ordReplacement: ordReplacement, + newtypeReplacement: newtypeReplacement, + showReplacement: showReplacement, + count: $foreign.count, + drop: $foreign.drop, + fromCharArray: $foreign.fromCharArray, + joinWith: $foreign.joinWith, + length: $foreign.length, + replace: $foreign.replace, + replaceAll: $foreign.replaceAll, + singleton: $foreign.singleton, + split: $foreign.split, + take: $foreign.take, + toCharArray: $foreign.toCharArray, + toLower: $foreign.toLower, + toUpper: $foreign.toUpper, + trim: $foreign.trim+};++},{"../Control.Semigroupoid":92,"../Data.Eq":138,"../Data.Function":149,"../Data.Maybe":198,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Ordering":217,"../Data.Ring":227,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Show":233,"../Data.String.Unsafe":239,"../Prelude":268,"./foreign":240}],242:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Apply = require("../Control.Apply");+var Control_Category = require("../Control.Category");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Eq = require("../Data.Eq");+var Data_EuclideanRing = require("../Data.EuclideanRing");+var Data_Generic = require("../Data.Generic");+var Data_Maybe = require("../Data.Maybe");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Ring = require("../Data.Ring");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Show = require("../Data.Show");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var Seconds = function (x) {+ return x;+};+var Minutes = function (x) {+ return x;+};+var Milliseconds = function (x) {+ return x;+};+var Hours = function (x) {+ return x;+};+var Days = function (x) {+ return x;+};+var Duration = function (fromDuration, toDuration) {+ this.fromDuration = fromDuration;+ this.toDuration = toDuration;+};+var toDuration = function (dict) {+ return dict.toDuration;+};+var showSeconds = new Data_Show.Show(function (v) {+ return "(Seconds " + (Data_Show.show(Data_Show.showNumber)(v) + ")");+});+var showMinutes = new Data_Show.Show(function (v) {+ return "(Minutes " + (Data_Show.show(Data_Show.showNumber)(v) + ")");+});+var showMilliseconds = new Data_Show.Show(function (v) {+ return "(Milliseconds " + (Data_Show.show(Data_Show.showNumber)(v) + ")");+});+var showHours = new Data_Show.Show(function (v) {+ return "(Hours " + (Data_Show.show(Data_Show.showNumber)(v) + ")");+});+var showDays = new Data_Show.Show(function (v) {+ return "(Days " + (Data_Show.show(Data_Show.showNumber)(v) + ")");+});+var semiringSeconds = Data_Semiring.semiringNumber;+var semiringMinutes = Data_Semiring.semiringNumber;+var semiringMilliseconds = Data_Semiring.semiringNumber;+var semiringHours = Data_Semiring.semiringNumber;+var semiringDays = Data_Semiring.semiringNumber;+var ringSeconds = Data_Ring.ringNumber;+var ringMinutes = Data_Ring.ringNumber;+var ringMilliseconds = Data_Ring.ringNumber;+var ringHours = Data_Ring.ringNumber;+var ringDays = Data_Ring.ringNumber;+var ordSeconds = Data_Ord.ordNumber;+var ordMinutes = Data_Ord.ordNumber;+var ordMilliseconds = Data_Ord.ordNumber;+var ordHours = Data_Ord.ordNumber;+var ordDays = Data_Ord.ordNumber;+var newtypeSeconds = new Data_Newtype.Newtype(function (n) {+ return n;+}, Seconds);+var newtypeMinutes = new Data_Newtype.Newtype(function (n) {+ return n;+}, Minutes);+var newtypeMilliseconds = new Data_Newtype.Newtype(function (n) {+ return n;+}, Milliseconds);+var newtypeHours = new Data_Newtype.Newtype(function (n) {+ return n;+}, Hours);+var newtypeDays = new Data_Newtype.Newtype(function (n) {+ return n;+}, Days);+var genericSeconds = new Data_Generic.Generic(function (v) {+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.Time.Duration.Seconds" && v.value1.length === 1)) {+ return Control_Apply.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(Seconds))(Data_Generic.fromSpine(Data_Generic.genericNumber)(v["value1"][0](Data_Unit.unit)));+ };+ return Data_Maybe.Nothing.value;+}, function ($dollarq) {+ return new Data_Generic.SigProd("Data.Time.Duration.Seconds", [ {+ sigConstructor: "Data.Time.Duration.Seconds", + sigValues: [ function ($dollarq1) {+ return Data_Generic.toSignature(Data_Generic.genericNumber)(Data_Generic.anyProxy);+ } ]+ } ]);+}, function (v) {+ return new Data_Generic.SProd("Data.Time.Duration.Seconds", [ function ($dollarq) {+ return Data_Generic.toSpine(Data_Generic.genericNumber)(v);+ } ]);+});+var genericMinutes = new Data_Generic.Generic(function (v) {+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.Time.Duration.Minutes" && v.value1.length === 1)) {+ return Control_Apply.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(Minutes))(Data_Generic.fromSpine(Data_Generic.genericNumber)(v["value1"][0](Data_Unit.unit)));+ };+ return Data_Maybe.Nothing.value;+}, function ($dollarq) {+ return new Data_Generic.SigProd("Data.Time.Duration.Minutes", [ {+ sigConstructor: "Data.Time.Duration.Minutes", + sigValues: [ function ($dollarq1) {+ return Data_Generic.toSignature(Data_Generic.genericNumber)(Data_Generic.anyProxy);+ } ]+ } ]);+}, function (v) {+ return new Data_Generic.SProd("Data.Time.Duration.Minutes", [ function ($dollarq) {+ return Data_Generic.toSpine(Data_Generic.genericNumber)(v);+ } ]);+});+var genericMilliseconds = new Data_Generic.Generic(function (v) {+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.Time.Duration.Milliseconds" && v.value1.length === 1)) {+ return Control_Apply.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(Milliseconds))(Data_Generic.fromSpine(Data_Generic.genericNumber)(v["value1"][0](Data_Unit.unit)));+ };+ return Data_Maybe.Nothing.value;+}, function ($dollarq) {+ return new Data_Generic.SigProd("Data.Time.Duration.Milliseconds", [ {+ sigConstructor: "Data.Time.Duration.Milliseconds", + sigValues: [ function ($dollarq1) {+ return Data_Generic.toSignature(Data_Generic.genericNumber)(Data_Generic.anyProxy);+ } ]+ } ]);+}, function (v) {+ return new Data_Generic.SProd("Data.Time.Duration.Milliseconds", [ function ($dollarq) {+ return Data_Generic.toSpine(Data_Generic.genericNumber)(v);+ } ]);+});+var genericHours = new Data_Generic.Generic(function (v) {+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.Time.Duration.Hours" && v.value1.length === 1)) {+ return Control_Apply.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(Hours))(Data_Generic.fromSpine(Data_Generic.genericNumber)(v["value1"][0](Data_Unit.unit)));+ };+ return Data_Maybe.Nothing.value;+}, function ($dollarq) {+ return new Data_Generic.SigProd("Data.Time.Duration.Hours", [ {+ sigConstructor: "Data.Time.Duration.Hours", + sigValues: [ function ($dollarq1) {+ return Data_Generic.toSignature(Data_Generic.genericNumber)(Data_Generic.anyProxy);+ } ]+ } ]);+}, function (v) {+ return new Data_Generic.SProd("Data.Time.Duration.Hours", [ function ($dollarq) {+ return Data_Generic.toSpine(Data_Generic.genericNumber)(v);+ } ]);+});+var genericDays = new Data_Generic.Generic(function (v) {+ if (v instanceof Data_Generic.SProd && (v.value0 === "Data.Time.Duration.Days" && v.value1.length === 1)) {+ return Control_Apply.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(Days))(Data_Generic.fromSpine(Data_Generic.genericNumber)(v["value1"][0](Data_Unit.unit)));+ };+ return Data_Maybe.Nothing.value;+}, function ($dollarq) {+ return new Data_Generic.SigProd("Data.Time.Duration.Days", [ {+ sigConstructor: "Data.Time.Duration.Days", + sigValues: [ function ($dollarq1) {+ return Data_Generic.toSignature(Data_Generic.genericNumber)(Data_Generic.anyProxy);+ } ]+ } ]);+}, function (v) {+ return new Data_Generic.SProd("Data.Time.Duration.Days", [ function ($dollarq) {+ return Data_Generic.toSpine(Data_Generic.genericNumber)(v);+ } ]);+});+var fromDuration = function (dict) {+ return dict.fromDuration;+};+var eqSeconds = Data_Eq.eqNumber;+var eqMinutes = Data_Eq.eqNumber;+var eqMilliseconds = Data_Eq.eqNumber;+var eqHours = Data_Eq.eqNumber;+var eqDays = Data_Eq.eqNumber;+var durationSeconds = new Duration(Data_Newtype.over(newtypeSeconds)(newtypeMilliseconds)(Seconds)(function (v) {+ return v * 1000.0;+}), Data_Newtype.over(newtypeMilliseconds)(newtypeSeconds)(Milliseconds)(function (v) {+ return v / 1000.0;+}));+var durationMinutes = new Duration(Data_Newtype.over(newtypeMinutes)(newtypeMilliseconds)(Minutes)(function (v) {+ return v * 60000.0;+}), Data_Newtype.over(newtypeMilliseconds)(newtypeMinutes)(Milliseconds)(function (v) {+ return v / 60000.0;+}));+var durationMilliseconds = new Duration(Control_Category.id(Control_Category.categoryFn), Control_Category.id(Control_Category.categoryFn));+var durationHours = new Duration(Data_Newtype.over(newtypeHours)(newtypeMilliseconds)(Hours)(function (v) {+ return v * 3600000.0;+}), Data_Newtype.over(newtypeMilliseconds)(newtypeHours)(Milliseconds)(function (v) {+ return v / 3600000.0;+}));+var durationDays = new Duration(Data_Newtype.over(newtypeDays)(newtypeMilliseconds)(Days)(function (v) {+ return v * 8.64e7;+}), Data_Newtype.over(newtypeMilliseconds)(newtypeDays)(Milliseconds)(function (v) {+ return v / 8.64e7;+}));+var convertDuration = function (dictDuration) {+ return function (dictDuration1) {+ return function ($80) {+ return toDuration(dictDuration1)(fromDuration(dictDuration)($80));+ };+ };+};+module.exports = {+ Days: Days, + Hours: Hours, + Milliseconds: Milliseconds, + Minutes: Minutes, + Seconds: Seconds, + Duration: Duration, + convertDuration: convertDuration, + fromDuration: fromDuration, + toDuration: toDuration, + newtypeMilliseconds: newtypeMilliseconds, + genericMilliseconds: genericMilliseconds, + eqMilliseconds: eqMilliseconds, + ordMilliseconds: ordMilliseconds, + semiringMilliseconds: semiringMilliseconds, + ringMilliseconds: ringMilliseconds, + showMilliseconds: showMilliseconds, + newtypeSeconds: newtypeSeconds, + genericSeconds: genericSeconds, + eqSeconds: eqSeconds, + ordSeconds: ordSeconds, + semiringSeconds: semiringSeconds, + ringSeconds: ringSeconds, + showSeconds: showSeconds, + newtypeMinutes: newtypeMinutes, + genericMinutes: genericMinutes, + eqMinutes: eqMinutes, + ordMinutes: ordMinutes, + semiringMinutes: semiringMinutes, + ringMinutes: ringMinutes, + showMinutes: showMinutes, + newtypeHours: newtypeHours, + genericHours: genericHours, + eqHours: eqHours, + ordHours: ordHours, + semiringHours: semiringHours, + ringHours: ringHours, + showHours: showHours, + newtypeDays: newtypeDays, + genericDays: genericDays, + eqDays: eqDays, + ordDays: ordDays, + semiringDays: semiringDays, + ringDays: ringDays, + showDays: showDays, + durationMilliseconds: durationMilliseconds, + durationSeconds: durationSeconds, + durationMinutes: durationMinutes, + durationHours: durationHours, + durationDays: durationDays+};++},{"../Control.Apply":42,"../Control.Category":47,"../Control.Semigroupoid":92,"../Data.Eq":138,"../Data.EuclideanRing":140,"../Data.Generic":157,"../Data.Maybe":198,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Ring":227,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Show":233,"../Data.Unit":249,"../Prelude":268}],243:[function(require,module,exports){+"use strict";++// jshint maxparams: 3++exports.traverseArrayImpl = function () {+ function Cont(fn) {+ this.fn = fn;+ }++ var emptyList = {};++ var ConsCell = function (head, tail) {+ this.head = head;+ this.tail = tail;+ };++ function consList(x) {+ return function (xs) {+ return new ConsCell(x, xs);+ };+ }++ function listToArray(list) {+ var arr = [];+ var xs = list;+ while (xs !== emptyList) {+ arr.push(xs.head);+ xs = xs.tail;+ }+ return arr;+ }++ return function (apply) {+ return function (map) {+ return function (pure) {+ return function (f) {+ var buildFrom = function (x, ys) {+ return apply(map(consList)(f(x)))(ys);+ };++ 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);+ });+ }+ };++ return function (array) {+ var result = go(pure(emptyList), array.length, array);+ while (result instanceof Cont) {+ result = result.fn();+ }++ return map(listToArray)(result);+ };+ };+ };+ };+ };+}();++},{}],244:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Category = require("../Control.Category");+var Data_Foldable = require("../Data.Foldable");+var Data_Functor = require("../Data.Functor");+var Data_Maybe = require("../Data.Maybe");+var Data_Maybe_First = require("../Data.Maybe.First");+var Data_Maybe_Last = require("../Data.Maybe.Last");+var Data_Monoid_Additive = require("../Data.Monoid.Additive");+var Data_Monoid_Conj = require("../Data.Monoid.Conj");+var Data_Monoid_Disj = require("../Data.Monoid.Disj");+var Data_Monoid_Dual = require("../Data.Monoid.Dual");+var Data_Monoid_Multiplicative = require("../Data.Monoid.Multiplicative");+var Prelude = require("../Prelude");+var StateL = function (x) {+ return x;+};+var StateR = function (x) {+ return x;+};+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 traversableMultiplicative = new Traversable(function () {+ return Data_Foldable.foldableMultiplicative;+}, function () {+ return Data_Monoid_Multiplicative.functorMultiplicative;+}, function (dictApplicative) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Monoid_Multiplicative.Multiplicative)(v);+ };+}, function (dictApplicative) {+ return function (f) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Monoid_Multiplicative.Multiplicative)(f(v));+ };+ };+});+var traversableMaybe = new Traversable(function () {+ return Data_Foldable.foldableMaybe;+}, function () {+ return Data_Maybe.functorMaybe;+}, function (dictApplicative) {+ return function (v) {+ if (v instanceof Data_Maybe.Nothing) {+ return Control_Applicative.pure(dictApplicative)(Data_Maybe.Nothing.value);+ };+ if (v instanceof Data_Maybe.Just) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Maybe.Just.create)(v.value0);+ };+ throw new Error("Failed pattern match at Data.Traversable line 87, column 3 - line 87, column 35: " + [ v.constructor.name ]);+ };+}, function (dictApplicative) {+ return function (v) {+ return function (v1) {+ if (v1 instanceof Data_Maybe.Nothing) {+ return Control_Applicative.pure(dictApplicative)(Data_Maybe.Nothing.value);+ };+ if (v1 instanceof Data_Maybe.Just) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Maybe.Just.create)(v(v1.value0));+ };+ throw new Error("Failed pattern match at Data.Traversable line 85, column 3 - line 85, column 37: " + [ v.constructor.name, v1.constructor.name ]);+ };+ };+});+var traversableDual = new Traversable(function () {+ return Data_Foldable.foldableDual;+}, function () {+ return Data_Monoid_Dual.functorDual;+}, function (dictApplicative) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Monoid_Dual.Dual)(v);+ };+}, function (dictApplicative) {+ return function (f) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Monoid_Dual.Dual)(f(v));+ };+ };+});+var traversableDisj = new Traversable(function () {+ return Data_Foldable.foldableDisj;+}, function () {+ return Data_Monoid_Disj.functorDisj;+}, function (dictApplicative) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Monoid_Disj.Disj)(v);+ };+}, function (dictApplicative) {+ return function (f) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Monoid_Disj.Disj)(f(v));+ };+ };+});+var traversableConj = new Traversable(function () {+ return Data_Foldable.foldableConj;+}, function () {+ return Data_Monoid_Conj.functorConj;+}, function (dictApplicative) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Monoid_Conj.Conj)(v);+ };+}, function (dictApplicative) {+ return function (f) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Monoid_Conj.Conj)(f(v));+ };+ };+});+var traversableAdditive = new Traversable(function () {+ return Data_Foldable.foldableAdditive;+}, function () {+ return Data_Monoid_Additive.functorAdditive;+}, function (dictApplicative) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Monoid_Additive.Additive)(v);+ };+}, function (dictApplicative) {+ return function (f) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Monoid_Additive.Additive)(f(v));+ };+ };+});+var stateR = function (v) {+ return v;+};+var stateL = function (v) {+ return v;+};+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;+};+var traversableFirst = new Traversable(function () {+ return Data_Foldable.foldableFirst;+}, function () {+ return Data_Maybe_First.functorFirst;+}, function (dictApplicative) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Maybe_First.First)(sequence(traversableMaybe)(dictApplicative)(v));+ };+}, function (dictApplicative) {+ return function (f) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Maybe_First.First)(traverse(traversableMaybe)(dictApplicative)(f)(v));+ };+ };+});+var traversableLast = new Traversable(function () {+ return Data_Foldable.foldableLast;+}, function () {+ return Data_Maybe_Last.functorLast;+}, function (dictApplicative) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Maybe_Last.Last)(sequence(traversableMaybe)(dictApplicative)(v));+ };+}, function (dictApplicative) {+ return function (f) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Data_Maybe_Last.Last)(traverse(traversableMaybe)(dictApplicative)(f)(v));+ };+ };+});+var traverseDefault = function (dictTraversable) {+ return function (dictApplicative) {+ return function (f) {+ return function (ta) {+ return sequence(dictTraversable)(dictApplicative)(Data_Functor.map(dictTraversable.Functor0())(f)(ta));+ };+ };+ };+};+var functorStateR = new Data_Functor.Functor(function (f) {+ return function (k) {+ return function (s) {+ var v = stateR(k)(s);+ return {+ accum: v.accum, + value: f(v.value)+ };+ };+ };+});+var functorStateL = new Data_Functor.Functor(function (f) {+ return function (k) {+ return function (s) {+ var v = stateL(k)(s);+ return {+ accum: v.accum, + value: f(v.value)+ };+ };+ };+});+var $$for = function (dictApplicative) {+ return function (dictTraversable) {+ return function (x) {+ return function (f) {+ return traverse(dictTraversable)(dictApplicative)(f)(x);+ };+ };+ };+};+var applyStateR = new Control_Apply.Apply(function () {+ return functorStateR;+}, function (f) {+ return function (x) {+ return function (s) {+ var v = stateR(x)(s);+ var v1 = stateR(f)(v.accum);+ return {+ accum: v1.accum, + value: v1.value(v.value)+ };+ };+ };+});+var applyStateL = new Control_Apply.Apply(function () {+ return functorStateL;+}, function (f) {+ return function (x) {+ return function (s) {+ var v = stateL(f)(s);+ var v1 = stateL(x)(v.accum);+ return {+ accum: v1.accum, + value: v.value(v1.value)+ };+ };+ };+});+var applicativeStateR = new Control_Applicative.Applicative(function () {+ return applyStateR;+}, function (a) {+ return function (s) {+ return {+ accum: s, + value: a+ };+ };+});+var mapAccumR = function (dictTraversable) {+ return function (f) {+ return function (s0) {+ return function (xs) {+ return stateR(traverse(dictTraversable)(applicativeStateR)(function (a) {+ return function (s) {+ return f(s)(a);+ };+ })(xs))(s0);+ };+ };+ };+};+var scanr = function (dictTraversable) {+ return function (f) {+ return function (b0) {+ return function (xs) {+ return (mapAccumR(dictTraversable)(function (b) {+ return function (a) {+ var b$prime = f(a)(b);+ return {+ accum: b$prime, + value: b$prime+ };+ };+ })(b0)(xs)).value;+ };+ };+ };+};+var applicativeStateL = new Control_Applicative.Applicative(function () {+ return applyStateL;+}, function (a) {+ return function (s) {+ return {+ accum: s, + value: a+ };+ };+});+var mapAccumL = function (dictTraversable) {+ return function (f) {+ return function (s0) {+ return function (xs) {+ return stateL(traverse(dictTraversable)(applicativeStateL)(function (a) {+ return function (s) {+ return f(s)(a);+ };+ })(xs))(s0);+ };+ };+ };+};+var scanl = function (dictTraversable) {+ return function (f) {+ return function (b0) {+ return function (xs) {+ return (mapAccumL(dictTraversable)(function (b) {+ return function (a) {+ var b$prime = f(b)(a);+ return {+ accum: b$prime, + value: b$prime+ };+ };+ })(b0)(xs)).value;+ };+ };+ };+};+module.exports = {+ Traversable: Traversable, + "for": $$for, + mapAccumL: mapAccumL, + mapAccumR: mapAccumR, + scanl: scanl, + scanr: scanr, + sequence: sequence, + sequenceDefault: sequenceDefault, + traverse: traverse, + traverseDefault: traverseDefault, + traversableArray: traversableArray, + traversableMaybe: traversableMaybe, + traversableFirst: traversableFirst, + traversableLast: traversableLast, + traversableAdditive: traversableAdditive, + traversableDual: traversableDual, + traversableConj: traversableConj, + traversableDisj: traversableDisj, + traversableMultiplicative: traversableMultiplicative+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Category":47,"../Data.Foldable":143,"../Data.Functor":155,"../Data.Maybe":198,"../Data.Maybe.First":196,"../Data.Maybe.Last":197,"../Data.Monoid.Additive":201,"../Data.Monoid.Conj":202,"../Data.Monoid.Disj":203,"../Data.Monoid.Dual":204,"../Data.Monoid.Multiplicative":206,"../Prelude":268,"./foreign":243}],245:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Biapplicative = require("../Control.Biapplicative");+var Control_Biapply = require("../Control.Biapply");+var Control_Bind = require("../Control.Bind");+var Control_Comonad = require("../Control.Comonad");+var Control_Extend = require("../Control.Extend");+var Control_Lazy = require("../Control.Lazy");+var Control_Monad = require("../Control.Monad");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Bifoldable = require("../Data.Bifoldable");+var Data_Bifunctor = require("../Data.Bifunctor");+var Data_Bitraversable = require("../Data.Bitraversable");+var Data_BooleanAlgebra = require("../Data.BooleanAlgebra");+var Data_Bounded = require("../Data.Bounded");+var Data_CommutativeRing = require("../Data.CommutativeRing");+var Data_Eq = require("../Data.Eq");+var Data_Foldable = require("../Data.Foldable");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Functor_Invariant = require("../Data.Functor.Invariant");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Maybe = require("../Data.Maybe");+var Data_Maybe_First = require("../Data.Maybe.First");+var Data_Monoid = require("../Data.Monoid");+var Data_Newtype = require("../Data.Newtype");+var Data_Ord = require("../Data.Ord");+var Data_Ordering = require("../Data.Ordering");+var Data_Ring = require("../Data.Ring");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Show = require("../Data.Show");+var Data_Traversable = require("../Data.Traversable");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+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 uncurry = function (f) {+ return function (v) {+ return f(v.value0)(v.value1);+ };+};+var swap = function (v) {+ return new Tuple(v.value1, v.value0);+};+var snd = function (v) {+ return v.value1;+};+var showTuple = function (dictShow) {+ return function (dictShow1) {+ return new Data_Show.Show(function (v) {+ return "(Tuple " + (Data_Show.show(dictShow)(v.value0) + (" " + (Data_Show.show(dictShow1)(v.value1) + ")")));+ });+ };+};+var semiringTuple = function (dictSemiring) {+ return function (dictSemiring1) {+ return new Data_Semiring.Semiring(function (v) {+ return function (v1) {+ return new Tuple(Data_Semiring.add(dictSemiring)(v.value0)(v1.value0), Data_Semiring.add(dictSemiring1)(v.value1)(v1.value1));+ };+ }, function (v) {+ return function (v1) {+ return new Tuple(Data_Semiring.mul(dictSemiring)(v.value0)(v1.value0), Data_Semiring.mul(dictSemiring1)(v.value1)(v1.value1));+ };+ }, new Tuple(Data_Semiring.one(dictSemiring), Data_Semiring.one(dictSemiring1)), new Tuple(Data_Semiring.zero(dictSemiring), Data_Semiring.zero(dictSemiring1)));+ };+};+var semigroupoidTuple = new Control_Semigroupoid.Semigroupoid(function (v) {+ return function (v1) {+ return new Tuple(v1.value0, v.value1);+ };+});+var semigroupTuple = function (dictSemigroup) {+ return function (dictSemigroup1) {+ return new Data_Semigroup.Semigroup(function (v) {+ return function (v1) {+ return new Tuple(Data_Semigroup.append(dictSemigroup)(v.value0)(v1.value0), Data_Semigroup.append(dictSemigroup1)(v.value1)(v1.value1));+ };+ });+ };+};+var ringTuple = function (dictRing) {+ return function (dictRing1) {+ return new Data_Ring.Ring(function () {+ return semiringTuple(dictRing.Semiring0())(dictRing1.Semiring0());+ }, function (v) {+ return function (v1) {+ return new Tuple(Data_Ring.sub(dictRing)(v.value0)(v1.value0), Data_Ring.sub(dictRing1)(v.value1)(v1.value1));+ };+ });+ };+};+var monoidTuple = function (dictMonoid) {+ return function (dictMonoid1) {+ return new Data_Monoid.Monoid(function () {+ return semigroupTuple(dictMonoid.Semigroup0())(dictMonoid1.Semigroup0());+ }, new Tuple(Data_Monoid.mempty(dictMonoid), Data_Monoid.mempty(dictMonoid1)));+ };+};+var lookup = function (dictFoldable) {+ return function (dictEq) {+ return function (a) {+ return function ($261) {+ return Data_Newtype.unwrap(Data_Maybe_First.newtypeFirst)(Data_Foldable.foldMap(dictFoldable)(Data_Maybe_First.monoidFirst)(function (v) {+ var $143 = Data_Eq.eq(dictEq)(a)(v.value0);+ if ($143) {+ return new Data_Maybe.Just(v.value1);+ };+ return Data_Maybe.Nothing.value;+ })($261));+ };+ };+ };+};+var heytingAlgebraTuple = function (dictHeytingAlgebra) {+ return function (dictHeytingAlgebra1) {+ return new Data_HeytingAlgebra.HeytingAlgebra(function (v) {+ return function (v1) {+ return new Tuple(Data_HeytingAlgebra.conj(dictHeytingAlgebra)(v.value0)(v1.value0), Data_HeytingAlgebra.conj(dictHeytingAlgebra1)(v.value1)(v1.value1));+ };+ }, function (v) {+ return function (v1) {+ return new Tuple(Data_HeytingAlgebra.disj(dictHeytingAlgebra)(v.value0)(v1.value0), Data_HeytingAlgebra.disj(dictHeytingAlgebra1)(v.value1)(v1.value1));+ };+ }, new Tuple(Data_HeytingAlgebra.ff(dictHeytingAlgebra), Data_HeytingAlgebra.ff(dictHeytingAlgebra1)), function (v) {+ return function (v1) {+ return new Tuple(Data_HeytingAlgebra.implies(dictHeytingAlgebra)(v.value0)(v1.value0), Data_HeytingAlgebra.implies(dictHeytingAlgebra1)(v.value1)(v1.value1));+ };+ }, function (v) {+ return new Tuple(Data_HeytingAlgebra.not(dictHeytingAlgebra)(v.value0), Data_HeytingAlgebra.not(dictHeytingAlgebra1)(v.value1));+ }, new Tuple(Data_HeytingAlgebra.tt(dictHeytingAlgebra), Data_HeytingAlgebra.tt(dictHeytingAlgebra1)));+ };+};+var functorTuple = new Data_Functor.Functor(function (f) {+ return function (v) {+ return new Tuple(v.value0, f(v.value1));+ };+});+var invariantTuple = new Data_Functor_Invariant.Invariant(Data_Functor_Invariant.imapF(functorTuple));+var fst = function (v) {+ return v.value0;+};+var lazyTuple = function (dictLazy) {+ return function (dictLazy1) {+ return new Control_Lazy.Lazy(function (f) {+ return new Tuple(Control_Lazy.defer(dictLazy)(function (v) {+ return fst(f(Data_Unit.unit));+ }), Control_Lazy.defer(dictLazy1)(function (v) {+ return snd(f(Data_Unit.unit));+ }));+ });+ };+};+var foldableTuple = new Data_Foldable.Foldable(function (dictMonoid) {+ return function (f) {+ return function (v) {+ return f(v.value1);+ };+ };+}, function (f) {+ return function (z) {+ return function (v) {+ return f(z)(v.value1);+ };+ };+}, function (f) {+ return function (z) {+ return function (v) {+ return f(v.value1)(z);+ };+ };+});+var traversableTuple = new Data_Traversable.Traversable(function () {+ return foldableTuple;+}, function () {+ return functorTuple;+}, function (dictApplicative) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Tuple.create(v.value0))(v.value1);+ };+}, function (dictApplicative) {+ return function (f) {+ return function (v) {+ return Data_Functor.map((dictApplicative.Apply0()).Functor0())(Tuple.create(v.value0))(f(v.value1));+ };+ };+});+var extendTuple = new Control_Extend.Extend(function () {+ return functorTuple;+}, function (f) {+ return function (v) {+ return new Tuple(v.value0, f(v));+ };+});+var eqTuple = function (dictEq) {+ return function (dictEq1) {+ return new Data_Eq.Eq(function (x) {+ return function (y) {+ return Data_Eq.eq(dictEq)(x.value0)(y.value0) && Data_Eq.eq(dictEq1)(x.value1)(y.value1);+ };+ });+ };+};+var ordTuple = function (dictOrd) {+ return function (dictOrd1) {+ return new Data_Ord.Ord(function () {+ return eqTuple(dictOrd.Eq0())(dictOrd1.Eq0());+ }, function (x) {+ return function (y) {+ var v = Data_Ord.compare(dictOrd)(x.value0)(y.value0);+ if (v instanceof Data_Ordering.LT) {+ return Data_Ordering.LT.value;+ };+ if (v instanceof Data_Ordering.GT) {+ return Data_Ordering.GT.value;+ };+ return Data_Ord.compare(dictOrd1)(x.value1)(y.value1);+ };+ });+ };+};+var eq1Tuple = function (dictEq) {+ return new Data_Eq.Eq1(function (dictEq1) {+ return Data_Eq.eq(eqTuple(dictEq)(dictEq1));+ });+};+var ord1Tuple = function (dictOrd) {+ return new Data_Ord.Ord1(function () {+ return eq1Tuple(dictOrd.Eq0());+ }, function (dictOrd1) {+ return Data_Ord.compare(ordTuple(dictOrd)(dictOrd1));+ });+};+var curry = function (f) {+ return function (a) {+ return function (b) {+ return f(new Tuple(a, b));+ };+ };+};+var comonadTuple = new Control_Comonad.Comonad(function () {+ return extendTuple;+}, snd);+var commutativeRingTuple = function (dictCommutativeRing) {+ return function (dictCommutativeRing1) {+ return new Data_CommutativeRing.CommutativeRing(function () {+ return ringTuple(dictCommutativeRing.Ring0())(dictCommutativeRing1.Ring0());+ });+ };+};+var boundedTuple = function (dictBounded) {+ return function (dictBounded1) {+ return new Data_Bounded.Bounded(function () {+ return ordTuple(dictBounded.Ord0())(dictBounded1.Ord0());+ }, new Tuple(Data_Bounded.bottom(dictBounded), Data_Bounded.bottom(dictBounded1)), new Tuple(Data_Bounded.top(dictBounded), Data_Bounded.top(dictBounded1)));+ };+};+var booleanAlgebraTuple = function (dictBooleanAlgebra) {+ return function (dictBooleanAlgebra1) {+ return new Data_BooleanAlgebra.BooleanAlgebra(function () {+ return heytingAlgebraTuple(dictBooleanAlgebra.HeytingAlgebra0())(dictBooleanAlgebra1.HeytingAlgebra0());+ });+ };+};+var bifunctorTuple = new Data_Bifunctor.Bifunctor(function (f) {+ return function (g) {+ return function (v) {+ return new Tuple(f(v.value0), g(v.value1));+ };+ };+});+var bifoldableTuple = new Data_Bifoldable.Bifoldable(function (dictMonoid) {+ return function (f) {+ return function (g) {+ return function (v) {+ return Data_Semigroup.append(dictMonoid.Semigroup0())(f(v.value0))(g(v.value1));+ };+ };+ };+}, function (f) {+ return function (g) {+ return function (z) {+ return function (v) {+ return g(f(z)(v.value0))(v.value1);+ };+ };+ };+}, function (f) {+ return function (g) {+ return function (z) {+ return function (v) {+ return f(v.value0)(g(v.value1)(z));+ };+ };+ };+});+var bitraversableTuple = new Data_Bitraversable.Bitraversable(function () {+ return bifoldableTuple;+}, function () {+ return bifunctorTuple;+}, function (dictApplicative) {+ return function (v) {+ return Control_Apply.apply(dictApplicative.Apply0())(Data_Functor.map((dictApplicative.Apply0()).Functor0())(Tuple.create)(v.value0))(v.value1);+ };+}, function (dictApplicative) {+ return function (f) {+ return function (g) {+ return function (v) {+ return Control_Apply.apply(dictApplicative.Apply0())(Data_Functor.map((dictApplicative.Apply0()).Functor0())(Tuple.create)(f(v.value0)))(g(v.value1));+ };+ };+ };+});+var biapplyTuple = new Control_Biapply.Biapply(function () {+ return bifunctorTuple;+}, function (v) {+ return function (v1) {+ return new Tuple(v.value0(v1.value0), v.value1(v1.value1));+ };+});+var biapplicativeTuple = new Control_Biapplicative.Biapplicative(function () {+ return biapplyTuple;+}, Tuple.create);+var applyTuple = function (dictSemigroup) {+ return new Control_Apply.Apply(function () {+ return functorTuple;+ }, function (v) {+ return function (v1) {+ return new Tuple(Data_Semigroup.append(dictSemigroup)(v.value0)(v1.value0), v.value1(v1.value1));+ };+ });+};+var bindTuple = function (dictSemigroup) {+ return new Control_Bind.Bind(function () {+ return applyTuple(dictSemigroup);+ }, function (v) {+ return function (f) {+ var v1 = f(v.value1);+ return new Tuple(Data_Semigroup.append(dictSemigroup)(v.value0)(v1.value0), v1.value1);+ };+ });+};+var applicativeTuple = function (dictMonoid) {+ return new Control_Applicative.Applicative(function () {+ return applyTuple(dictMonoid.Semigroup0());+ }, Tuple.create(Data_Monoid.mempty(dictMonoid)));+};+var monadTuple = function (dictMonoid) {+ return new Control_Monad.Monad(function () {+ return applicativeTuple(dictMonoid);+ }, function () {+ return bindTuple(dictMonoid.Semigroup0());+ });+};+module.exports = {+ Tuple: Tuple, + curry: curry, + fst: fst, + lookup: lookup, + snd: snd, + swap: swap, + uncurry: uncurry, + showTuple: showTuple, + eqTuple: eqTuple, + eq1Tuple: eq1Tuple, + ordTuple: ordTuple, + ord1Tuple: ord1Tuple, + boundedTuple: boundedTuple, + semigroupoidTuple: semigroupoidTuple, + semigroupTuple: semigroupTuple, + monoidTuple: monoidTuple, + semiringTuple: semiringTuple, + ringTuple: ringTuple, + commutativeRingTuple: commutativeRingTuple, + heytingAlgebraTuple: heytingAlgebraTuple, + booleanAlgebraTuple: booleanAlgebraTuple, + functorTuple: functorTuple, + invariantTuple: invariantTuple, + bifunctorTuple: bifunctorTuple, + applyTuple: applyTuple, + biapplyTuple: biapplyTuple, + applicativeTuple: applicativeTuple, + biapplicativeTuple: biapplicativeTuple, + bindTuple: bindTuple, + monadTuple: monadTuple, + extendTuple: extendTuple, + comonadTuple: comonadTuple, + lazyTuple: lazyTuple, + foldableTuple: foldableTuple, + bifoldableTuple: bifoldableTuple, + traversableTuple: traversableTuple, + bitraversableTuple: bitraversableTuple+};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Biapplicative":43,"../Control.Biapply":44,"../Control.Bind":46,"../Control.Comonad":48,"../Control.Extend":49,"../Control.Lazy":50,"../Control.Monad":86,"../Control.Semigroupoid":92,"../Data.Bifoldable":121,"../Data.Bifunctor":127,"../Data.Bitraversable":128,"../Data.BooleanAlgebra":130,"../Data.Bounded":132,"../Data.CommutativeRing":133,"../Data.Eq":138,"../Data.Foldable":143,"../Data.Function":149,"../Data.Functor":155,"../Data.Functor.Invariant":153,"../Data.HeytingAlgebra":160,"../Data.Maybe":198,"../Data.Maybe.First":196,"../Data.Monoid":207,"../Data.Newtype":209,"../Data.Ord":216,"../Data.Ordering":217,"../Data.Ring":227,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Show":233,"../Data.Traversable":244,"../Data.Unit":249,"../Prelude":268}],246:[function(require,module,exports){+"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);+ }+ };+ };+ };+ };+ };+};++},{}],247:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_Maybe = require("../Data.Maybe");+var Data_Ord = require("../Data.Ord");+var Data_Ring = require("../Data.Ring");+var Data_Traversable = require("../Data.Traversable");+var Data_Tuple = require("../Data.Tuple");+var Data_Unit = require("../Data.Unit");+var Partial_Unsafe = require("../Partial.Unsafe");+var Prelude = require("../Prelude");+var Unfoldable = function (unfoldr) {+ this.unfoldr = unfoldr;+};+var unfoldr = function (dict) {+ return dict.unfoldr;+};+var unfoldableArray = new Unfoldable($foreign.unfoldrArrayImpl(Data_Maybe.isNothing)(Data_Maybe.fromJust())(Data_Tuple.fst)(Data_Tuple.snd));+var replicate = function (dictUnfoldable) {+ return function (n) {+ return function (v) {+ var step = function (i) {+ var $8 = i <= 0;+ if ($8) {+ return Data_Maybe.Nothing.value;+ };+ return new Data_Maybe.Just(new Data_Tuple.Tuple(v, i - 1 | 0));+ };+ return unfoldr(dictUnfoldable)(step)(n);+ };+ };+};+var replicateA = function (dictApplicative) {+ return function (dictUnfoldable) {+ return function (dictTraversable) {+ return function (n) {+ return function (m) {+ return Data_Traversable.sequence(dictTraversable)(dictApplicative)(replicate(dictUnfoldable)(n)(m));+ };+ };+ };+ };+};+var singleton = function (dictUnfoldable) {+ return replicate(dictUnfoldable)(1);+};+var none = function (dictUnfoldable) {+ return unfoldr(dictUnfoldable)(Data_Function["const"](Data_Maybe.Nothing.value))(Data_Unit.unit);+};+var fromMaybe = function (dictUnfoldable) {+ return unfoldr(dictUnfoldable)(function (b) {+ return Data_Functor.map(Data_Maybe.functorMaybe)(Data_Function.flip(Data_Tuple.Tuple.create)(Data_Maybe.Nothing.value))(b);+ });+};+module.exports = {+ Unfoldable: Unfoldable, + fromMaybe: fromMaybe, + none: none, + replicate: replicate, + replicateA: replicateA, + singleton: singleton, + unfoldr: unfoldr, + unfoldableArray: unfoldableArray+};++},{"../Data.Function":149,"../Data.Functor":155,"../Data.Maybe":198,"../Data.Ord":216,"../Data.Ring":227,"../Data.Traversable":244,"../Data.Tuple":245,"../Data.Unit":249,"../Partial.Unsafe":265,"../Prelude":268,"./foreign":246}],248:[function(require,module,exports){+"use strict";++exports.unit = {};++},{}],249:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Data_Show = require("../Data.Show");+var showUnit = new Data_Show.Show(function (v) {+ return "unit";+});+module.exports = {+ showUnit: showUnit, + unit: $foreign.unit+};++},{"../Data.Show":233,"./foreign":248}],250:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Show = require("../Data.Show");+var Void = function (x) {+ return x;+};+var absurd = function (a) {+ var spin = function (__copy_v) {+ var v = __copy_v;+ var __tco_result;+ var __tco_v;+ function __tco_loop(v) {+ __tco_v = v;+ return;+ };+ while (!false) {+ __tco_result = __tco_loop(v);+ v = __tco_v;+ };+ return __tco_result;+ };+ return spin(a);+};+var showVoid = new Data_Show.Show(absurd);+module.exports = {+ absurd: absurd, + showVoid: showVoid+};++},{"../Data.Show":233}],251:[function(require,module,exports){+/* globals exports */+"use strict";++// module Global++exports.nan = NaN;++exports.isNaN = isNaN;++exports.infinity = Infinity;++exports.isFinite = isFinite;++exports.readInt = function (radix) {+ return function (n) {+ return parseInt(n, radix);+ };+};++exports.readFloat = parseFloat;++exports.decodeURI = decodeURI;+exports.encodeURI = encodeURI;+exports.decodeURIComponent = decodeURIComponent;+exports.encodeURIComponent = encodeURIComponent;++},{}],252:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+module.exports = {+ "decodeURI": $foreign["decodeURI"], + "decodeURIComponent": $foreign["decodeURIComponent"], + "encodeURI": $foreign["encodeURI"], + "encodeURIComponent": $foreign["encodeURIComponent"], + infinity: $foreign.infinity, + "isFinite": $foreign["isFinite"], + "isNaN": $foreign["isNaN"], + nan: $foreign.nan, + readFloat: $foreign.readFloat, + readInt: $foreign.readInt+};++},{"./foreign":251}],253:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Common = require("../Common");+var Control_Applicative = require("../Control.Applicative");+var Control_Bind = require("../Control.Bind");+var Control_Monad_Aff = require("../Control.Monad.Aff");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var Control_Monad_Eff_Console = require("../Control.Monad.Eff.Console");+var Control_Monad_Eff_Exception = require("../Control.Monad.Eff.Exception");+var Control_Monad_Eff_JQuery = require("../Control.Monad.Eff.JQuery");+var DOM = require("../DOM");+var Data_Argonaut = require("../Data.Argonaut");+var Data_Argonaut_Core = require("../Data.Argonaut.Core");+var Data_Argonaut_Decode = require("../Data.Argonaut.Decode");+var Data_Argonaut_Decode_Class = require("../Data.Argonaut.Decode.Class");+var Data_Either = require("../Data.Either");+var Data_FormURLEncoded = require("../Data.FormURLEncoded");+var Data_Function = require("../Data.Function");+var Data_Function_Uncurried = require("../Data.Function.Uncurried");+var Data_Functor = require("../Data.Functor");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Maybe = require("../Data.Maybe");+var Data_Show = require("../Data.Show");+var Data_Tuple = require("../Data.Tuple");+var Data_Unit = require("../Data.Unit");+var Network_HTTP_Affjax = require("../Network.HTTP.Affjax");+var Network_HTTP_Affjax_Request = require("../Network.HTTP.Affjax.Request");+var Network_HTTP_Affjax_Response = require("../Network.HTTP.Affjax.Response");+var Partial_Unsafe = require("../Partial.Unsafe");+var Prelude = require("../Prelude");+var resp1Success = function (pass) {+ return function (j) {+ return function (loc) {+ return function __do() {+ Control_Monad_Eff_Console.log(Data_Show.show(Data_Argonaut_Core.showJson)(j))();+ var eitherChallenge = Data_Argonaut_Decode_Class.decodeJson(Common.decodeJsonChallenge)(j);+ if (eitherChallenge instanceof Data_Either.Left) {+ var eitherErr = Data_Argonaut_Decode_Class.decodeJson(Common.decodeJsonErr)(j);+ return Data_Either.either(Common.fail(Common.Login.value))(function (v) {+ return Common.fail(Common.Login.value)(v.value0.err);+ })(eitherErr)();+ };+ if (eitherChallenge instanceof Data_Either.Right) {+ Common.progress("HMAC 1")();+ var salted = Common.hmacSha3(Common.fromUtf8(pass), Common.fromHex(eitherChallenge.value0.value0.salt));+ Common.progress("HMAC 2")();+ var response = Common.hmacSha3(Common.fromUtf8(salted), Common.fromUtf8(eitherChallenge.value0.value0.token));+ Common.progress("sending response")();+ var data2 = Data_FormURLEncoded.fromArray([ new Data_Tuple.Tuple("token", new Data_Maybe.Just(eitherChallenge.value0.value0.token)), new Data_Tuple.Tuple("response", new Data_Maybe.Just(response)) ]);+ var v = Control_Monad_Aff.runAff(function (e) {+ return Common.fail(Common.Login.value)(Data_Show.show(Control_Monad_Eff_Exception.showError)(e));+ })(function (x) {+ return Common.welcome(x.response)(Common.Login.value);+ })(Network_HTTP_Affjax.post(Network_HTTP_Affjax_Request.requestableFormURLEncoded)(Network_HTTP_Affjax_Response.responsableJson)(loc)(data2))();+ return Data_Unit.unit;+ };+ throw new Error("Failed pattern match at Login line 87, column 3 - line 104, column 12: " + [ eitherChallenge.constructor.name ]);+ };+ };+ };+};+var onLoginClick = function (login) {+ return function (ev) {+ return function (x) {+ return function __do() {+ Control_Monad_Eff_Console.log("click!")();+ Control_Monad_Eff_JQuery.preventDefault(ev)();+ Control_Monad_Eff_JQuery.hide(login)();+ var v = Data_Functor.map(Control_Monad_Eff.functorEff)(Control_Monad_Eff_JQuery.setProp("disabled")(true))(Control_Monad_Eff_JQuery.select(".login input"))();+ var v1 = Control_Bind.bindFlipped(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.getValue)(Control_Monad_Eff_JQuery.select("#username"))();+ var v2 = Control_Bind.bindFlipped(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.getValue)(Control_Monad_Eff_JQuery.select("#password"))();+ var v3 = Control_Bind.bindFlipped(Control_Monad_Eff.bindEff)(Common.getAttr("action"))(Control_Monad_Eff_JQuery.select("#loginform"))();+ Control_Monad_Eff_Console.log(v3)();+ var username = Common.fromForeign(v1);+ var password = Common.fromForeign(v2);+ var $17 = !(Data_Maybe.isNothing(username) && Data_Maybe.isNothing(password));+ if ($17) {+ Common.progress("Obtaining Challenge...")();+ var data1 = Data_FormURLEncoded.fromArray([ new Data_Tuple.Tuple("username", username) ]);+ var v4 = Control_Monad_Aff.runAff(function (e) {+ return Common.fail(Common.Login.value)(Data_Show.show(Control_Monad_Eff_Exception.showError)(e));+ })(function (y) {+ return resp1Success(Data_Maybe.fromJust()(password))(y.response)(v3);+ })(Network_HTTP_Affjax.post(Network_HTTP_Affjax_Request.requestableFormURLEncoded)(Network_HTTP_Affjax_Response.responsableJson)(v3)(data1))();+ return Control_Monad_Eff_Console.log("success so far")();+ };+ return Control_Monad_Eff_Console.log("error")();+ };+ };+ };+};+module.exports = {+ onLoginClick: onLoginClick, + resp1Success: resp1Success+};++},{"../Common":37,"../Control.Applicative":40,"../Control.Bind":46,"../Control.Monad.Aff":55,"../Control.Monad.Eff":70,"../Control.Monad.Eff.Console":60,"../Control.Monad.Eff.Exception":62,"../Control.Monad.Eff.JQuery":64,"../DOM":100,"../Data.Argonaut":114,"../Data.Argonaut.Core":102,"../Data.Argonaut.Decode":105,"../Data.Argonaut.Decode.Class":103,"../Data.Either":136,"../Data.FormURLEncoded":146,"../Data.Function":149,"../Data.Function.Uncurried":148,"../Data.Functor":155,"../Data.HeytingAlgebra":160,"../Data.Maybe":198,"../Data.Show":233,"../Data.Tuple":245,"../Data.Unit":249,"../Network.HTTP.Affjax":260,"../Network.HTTP.Affjax.Request":257,"../Network.HTTP.Affjax.Response":258,"../Partial.Unsafe":265,"../Prelude":268}],254:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Activate = require("../Activate");+var Control_Bind = require("../Control.Bind");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var Control_Monad_Eff_Console = require("../Control.Monad.Eff.Console");+var Control_Monad_Eff_JQuery = require("../Control.Monad.Eff.JQuery");+var DOM = require("../DOM");+var Data_Function = require("../Data.Function");+var Login = require("../Login");+var Network_HTTP_Affjax = require("../Network.HTTP.Affjax");+var Prelude = require("../Prelude");+var main = Control_Monad_Eff_JQuery.ready(function __do() {+ Control_Monad_Eff_Console.log("let's go")();+ Control_Bind.bindFlipped(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.display)(Control_Monad_Eff_JQuery.select(".js-hidden"))();+ Control_Bind.bindFlipped(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.hide)(Control_Monad_Eff_JQuery.select(".noscript"))();+ var v = Control_Monad_Eff_JQuery.select("#activate")();+ var v1 = Control_Monad_Eff_JQuery.select("#login")();+ Control_Monad_Eff_JQuery.on("click")(Activate.onActivateClick(v))(v)();+ return Control_Monad_Eff_JQuery.on("click")(Login.onLoginClick(v))(v1)();+});+module.exports = {+ main: main+};++},{"../Activate":35,"../Control.Bind":46,"../Control.Monad.Eff":70,"../Control.Monad.Eff.Console":60,"../Control.Monad.Eff.JQuery":64,"../DOM":100,"../Data.Function":149,"../Login":253,"../Network.HTTP.Affjax":260,"../Prelude":268}],255:[function(require,module,exports){+"use strict";++// module Math++exports.abs = Math.abs;++exports.acos = Math.acos;++exports.asin = Math.asin;++exports.atan = Math.atan;++exports.atan2 = function (y) {+ return function (x) {+ return Math.atan2(y, x);+ };+};++exports.ceil = Math.ceil;++exports.cos = Math.cos;++exports.exp = Math.exp;++exports.floor = Math.floor;++exports.trunc = Math.trunc || function (n) {+ return n < 0 ? Math.ceil(n) : Math.floor(n);+};++exports.log = Math.log;++exports.max = function (n1) {+ return function (n2) {+ return Math.max(n1, n2);+ };+};++exports.min = function (n1) {+ return function (n2) {+ return Math.min(n1, n2);+ };+};++exports.pow = function (n) {+ return function (p) {+ return Math.pow(n, p);+ };+};++exports.remainder = function (n) {+ return function (m) {+ return n % m;+ };+};++exports.round = Math.round;++exports.sin = Math.sin;++exports.sqrt = Math.sqrt;++exports.tan = Math.tan;++exports.e = Math.E;++exports.ln2 = Math.LN2;++exports.ln10 = Math.LN10;++exports.log2e = Math.LOG2E;++exports.log10e = Math.LOG10E;++exports.pi = Math.PI;++exports.sqrt1_2 = Math.SQRT1_2;++exports.sqrt2 = Math.SQRT2;++},{}],256:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+module.exports = {+ abs: $foreign.abs, + acos: $foreign.acos, + asin: $foreign.asin, + atan: $foreign.atan, + atan2: $foreign.atan2, + ceil: $foreign.ceil, + cos: $foreign.cos, + e: $foreign.e, + exp: $foreign.exp, + floor: $foreign.floor, + ln10: $foreign.ln10, + ln2: $foreign.ln2, + log: $foreign.log, + log10e: $foreign.log10e, + log2e: $foreign.log2e, + max: $foreign.max, + min: $foreign.min, + pi: $foreign.pi, + pow: $foreign.pow, + remainder: $foreign.remainder, + round: $foreign.round, + sin: $foreign.sin, + sqrt: $foreign.sqrt, + sqrt1_2: $foreign.sqrt1_2, + sqrt2: $foreign.sqrt2, + tan: $foreign.tan, + trunc: $foreign.trunc+};++},{"./foreign":255}],257:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Semigroupoid = require("../Control.Semigroupoid");+var DOM_File_Types = require("../DOM.File.Types");+var DOM_Node_Types = require("../DOM.Node.Types");+var DOM_XHR_Types = require("../DOM.XHR.Types");+var Data_Argonaut_Core = require("../Data.Argonaut.Core");+var Data_ArrayBuffer_Types = require("../Data.ArrayBuffer.Types");+var Data_FormURLEncoded = require("../Data.FormURLEncoded");+var Data_Maybe = require("../Data.Maybe");+var Data_MediaType = require("../Data.MediaType");+var Data_MediaType_Common = require("../Data.MediaType.Common");+var Data_Show = require("../Data.Show");+var Data_Tuple = require("../Data.Tuple");+var Prelude = require("../Prelude");+var Unsafe_Coerce = require("../Unsafe.Coerce");+var Requestable = function (toRequest) {+ this.toRequest = toRequest;+};+var toRequest = function (dict) {+ return dict.toRequest;+};+var requestableJson = new Requestable(function (json) {+ return new Data_Tuple.Tuple(new Data_Maybe.Just(Data_MediaType_Common.applicationJSON), Unsafe_Coerce.unsafeCoerce(Data_Show.show(Data_Argonaut_Core.showJson)(json)));+});+var requestableFormURLEncoded = new Requestable(function (form) {+ return new Data_Tuple.Tuple(new Data_Maybe.Just(Data_MediaType_Common.applicationFormURLEncoded), Unsafe_Coerce.unsafeCoerce(Data_FormURLEncoded.encode(form)));+});+var defaultToRequest = function ($0) {+ return Data_Tuple.Tuple.create(Data_Maybe.Nothing.value)(Unsafe_Coerce.unsafeCoerce($0));+};+var requestableBlob = new Requestable(defaultToRequest);+var requestableDocument = new Requestable(defaultToRequest);+var requestableFloat32Array = new Requestable(defaultToRequest);+var requestableFloat64Array = new Requestable(defaultToRequest);+var requestableFormData = new Requestable(defaultToRequest);+var requestableInt16Array = new Requestable(defaultToRequest);+var requestableInt32Array = new Requestable(defaultToRequest);+var requestableInt8Array = new Requestable(defaultToRequest);+var requestableRequestContent = new Requestable(defaultToRequest);+var requestableString = new Requestable(defaultToRequest);+var requestableUint16Array = new Requestable(defaultToRequest);+var requestableUint32Array = new Requestable(defaultToRequest);+var requestableUint8Array = new Requestable(defaultToRequest);+var requestableUint8ClampedArray = new Requestable(defaultToRequest);+var requestableUnit = new Requestable(defaultToRequest);+module.exports = {+ Requestable: Requestable, + toRequest: toRequest, + requestableRequestContent: requestableRequestContent, + requestableInt8Array: requestableInt8Array, + requestableInt16Array: requestableInt16Array, + requestableInt32Array: requestableInt32Array, + requestableUint8Array: requestableUint8Array, + requestableUint16Array: requestableUint16Array, + requestableUint32Array: requestableUint32Array, + requestableUint8ClampedArray: requestableUint8ClampedArray, + requestableFloat32Array: requestableFloat32Array, + requestableFloat64Array: requestableFloat64Array, + requestableBlob: requestableBlob, + requestableDocument: requestableDocument, + requestableString: requestableString, + requestableJson: requestableJson, + requestableFormData: requestableFormData, + requestableFormURLEncoded: requestableFormURLEncoded, + requestableUnit: requestableUnit+};++},{"../Control.Semigroupoid":92,"../DOM.File.Types":95,"../DOM.Node.Types":96,"../DOM.XHR.Types":99,"../Data.Argonaut.Core":102,"../Data.ArrayBuffer.Types":120,"../Data.FormURLEncoded":146,"../Data.Maybe":198,"../Data.MediaType":200,"../Data.MediaType.Common":199,"../Data.Show":233,"../Data.Tuple":245,"../Prelude":268,"../Unsafe.Coerce":271}],258:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Monad_Except_Trans = require("../Control.Monad.Except.Trans");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var DOM_File_Types = require("../DOM.File.Types");+var DOM_Node_Types = require("../DOM.Node.Types");+var Data_Argonaut_Core = require("../Data.Argonaut.Core");+var Data_ArrayBuffer_Types = require("../Data.ArrayBuffer.Types");+var Data_Eq = require("../Data.Eq");+var Data_Foreign = require("../Data.Foreign");+var Data_Function = require("../Data.Function");+var Data_Identity = require("../Data.Identity");+var Data_Maybe = require("../Data.Maybe");+var Data_MediaType = require("../Data.MediaType");+var Data_MediaType_Common = require("../Data.MediaType.Common");+var Data_Show = require("../Data.Show");+var Data_Tuple = require("../Data.Tuple");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var Unsafe_Coerce = require("../Unsafe.Coerce");+var ArrayBufferResponse = (function () {+ function ArrayBufferResponse() {++ };+ ArrayBufferResponse.value = new ArrayBufferResponse();+ return ArrayBufferResponse;+})();+var BlobResponse = (function () {+ function BlobResponse() {++ };+ BlobResponse.value = new BlobResponse();+ return BlobResponse;+})();+var DocumentResponse = (function () {+ function DocumentResponse() {++ };+ DocumentResponse.value = new DocumentResponse();+ return DocumentResponse;+})();+var JSONResponse = (function () {+ function JSONResponse() {++ };+ JSONResponse.value = new JSONResponse();+ return JSONResponse;+})();+var StringResponse = (function () {+ function StringResponse() {++ };+ StringResponse.value = new StringResponse();+ return StringResponse;+})();+var Respondable = function (fromResponse, responseType) {+ this.fromResponse = fromResponse;+ this.responseType = responseType;+};+var showResponseType = new Data_Show.Show(function (v) {+ if (v instanceof ArrayBufferResponse) {+ return "ArrayBufferResponse";+ };+ if (v instanceof BlobResponse) {+ return "BlobResponse";+ };+ if (v instanceof DocumentResponse) {+ return "DocumentResponse";+ };+ if (v instanceof JSONResponse) {+ return "JSONResponse";+ };+ if (v instanceof StringResponse) {+ return "StringResponse";+ };+ throw new Error("Failed pattern match at Network.HTTP.Affjax.Response line 42, column 3 - line 43, column 3: " + [ v.constructor.name ]);+});+var responseTypeToString = function (v) {+ if (v instanceof ArrayBufferResponse) {+ return "arraybuffer";+ };+ if (v instanceof BlobResponse) {+ return "blob";+ };+ if (v instanceof DocumentResponse) {+ return "document";+ };+ if (v instanceof JSONResponse) {+ return "text";+ };+ if (v instanceof StringResponse) {+ return "text";+ };+ throw new Error("Failed pattern match at Network.HTTP.Affjax.Response line 49, column 1 - line 50, column 1: " + [ v.constructor.name ]);+};+var responseType = function (dict) {+ return dict.responseType;+};+var responsableUnit = new Respondable(Data_Function["const"](Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_Unit.unit)), new Data_Tuple.Tuple(Data_Maybe.Nothing.value, StringResponse.value));+var responsableString = new Respondable(Data_Foreign.readString, new Data_Tuple.Tuple(Data_Maybe.Nothing.value, StringResponse.value));+var responsableJson = new Respondable(function ($8) {+ return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Unsafe_Coerce.unsafeCoerce($8));+}, new Data_Tuple.Tuple(new Data_Maybe.Just(Data_MediaType_Common.applicationJSON), JSONResponse.value));+var responsableForeign = new Respondable(function ($9) {+ return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Unsafe_Coerce.unsafeCoerce($9));+}, new Data_Tuple.Tuple(Data_Maybe.Nothing.value, JSONResponse.value));+var responsableDocument = new Respondable(Data_Foreign.unsafeReadTagged("Document"), new Data_Tuple.Tuple(Data_Maybe.Nothing.value, DocumentResponse.value));+var responsableBlob = new Respondable(Data_Foreign.unsafeReadTagged("Blob"), new Data_Tuple.Tuple(Data_Maybe.Nothing.value, BlobResponse.value));+var responsableArrayBuffer = new Respondable(Data_Foreign.unsafeReadTagged("ArrayBuffer"), new Data_Tuple.Tuple(Data_Maybe.Nothing.value, ArrayBufferResponse.value));+var fromResponse = function (dict) {+ return dict.fromResponse;+};+var eqResponseType = new Data_Eq.Eq(function (v) {+ return function (v1) {+ if (v instanceof ArrayBufferResponse && v1 instanceof ArrayBufferResponse) {+ return true;+ };+ if (v instanceof BlobResponse && v1 instanceof BlobResponse) {+ return true;+ };+ if (v instanceof DocumentResponse && v1 instanceof DocumentResponse) {+ return true;+ };+ if (v instanceof JSONResponse && v1 instanceof JSONResponse) {+ return true;+ };+ if (v instanceof StringResponse && v1 instanceof StringResponse) {+ return true;+ };+ return false;+ };+});+module.exports = {+ ArrayBufferResponse: ArrayBufferResponse, + BlobResponse: BlobResponse, + DocumentResponse: DocumentResponse, + JSONResponse: JSONResponse, + StringResponse: StringResponse, + Respondable: Respondable, + fromResponse: fromResponse, + responseType: responseType, + responseTypeToString: responseTypeToString, + eqResponseType: eqResponseType, + showResponseType: showResponseType, + responsableBlob: responsableBlob, + responsableDocument: responsableDocument, + responsableForeign: responsableForeign, + responsableString: responsableString, + responsableUnit: responsableUnit, + responsableArrayBuffer: responsableArrayBuffer, + responsableJson: responsableJson+};++},{"../Control.Applicative":40,"../Control.Monad.Except.Trans":72,"../Control.Semigroupoid":92,"../DOM.File.Types":95,"../DOM.Node.Types":96,"../Data.Argonaut.Core":102,"../Data.ArrayBuffer.Types":120,"../Data.Eq":138,"../Data.Foreign":145,"../Data.Function":149,"../Data.Identity":161,"../Data.Maybe":198,"../Data.MediaType":200,"../Data.MediaType.Common":199,"../Data.Show":233,"../Data.Tuple":245,"../Data.Unit":249,"../Prelude":268,"../Unsafe.Coerce":271}],259:[function(require,module,exports){+(function (process){+/* global exports */+/* global XMLHttpRequest */+/* global module */+/* global process */+"use strict";++// module Network.HTTP.Affjax++// jshint maxparams: 5+exports._ajax = function (mkHeader, options, canceler, errback, callback) {+ var platformSpecific = { };+ if (typeof module !== "undefined" && module.require && !(typeof process !== "undefined" && process.versions["electron"])) {+ // We are on node.js+ platformSpecific.newXHR = function () {+ var XHR = module.require("xhr2");+ return new XHR();+ };++ platformSpecific.fixupUrl = function (url) {+ var urllib = module.require("url");+ var u = urllib.parse(url);+ u.protocol = u.protocol || "http:";+ u.hostname = u.hostname || "localhost";+ return urllib.format(u);+ };++ platformSpecific.getResponse = function (xhr) {+ return xhr.response;+ };+ } else {+ // We are in the browser+ platformSpecific.newXHR = function () {+ return new XMLHttpRequest();+ };++ platformSpecific.fixupUrl = function (url) {+ return url || "/";+ };++ platformSpecific.getResponse = function (xhr) {+ return xhr.response;+ };+ }++ return function () {+ var xhr = platformSpecific.newXHR();+ var fixedUrl = platformSpecific.fixupUrl(options.url);+ xhr.open(options.method || "GET", fixedUrl, true, options.username, options.password);+ if (options.headers) {+ try {+ for (var i = 0, header; (header = options.headers[i]) != null; i++) {+ xhr.setRequestHeader(header.field, header.value);+ }+ }+ catch (e) {+ errback(e)();+ }+ }+ xhr.onerror = function () {+ errback(new Error("AJAX request failed: " + options.method + " " + options.url))();+ };+ xhr.onload = function () {+ callback({+ status: xhr.status,+ headers: xhr.getAllResponseHeaders().split("\r\n")+ .filter(function (header) {+ return header.length > 0;+ })+ .map(function (header) {+ var i = header.indexOf(":");+ return mkHeader(header.substring(0, i))(header.substring(i + 2));+ }),+ response: platformSpecific.getResponse(xhr)+ })();+ };+ xhr.responseType = options.responseType;+ xhr.withCredentials = options.withCredentials;+ xhr.send(options.content);+ return canceler(xhr);+ };+};++// jshint maxparams: 4+exports._cancelAjax = function (xhr, cancelError, errback, callback) {+ return function () {+ try { xhr.abort(); } catch (e) { return callback(false)(); }+ return callback(true)();+ };+};+++}).call(this,require('_process'))+},{"_process":273}],260:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Control_Applicative = require("../Control.Applicative");+var Control_Bind = require("../Control.Bind");+var Control_Monad_Aff = require("../Control.Monad.Aff");+var Control_Monad_Aff_AVar = require("../Control.Monad.Aff.AVar");+var Control_Monad_Eff = require("../Control.Monad.Eff");+var Control_Monad_Eff_Class = require("../Control.Monad.Eff.Class");+var Control_Monad_Eff_Exception = require("../Control.Monad.Eff.Exception");+var Control_Monad_Eff_Ref = require("../Control.Monad.Eff.Ref");+var Control_Monad_Error_Class = require("../Control.Monad.Error.Class");+var Control_Monad_Except = require("../Control.Monad.Except");+var Control_Monad_Except_Trans = require("../Control.Monad.Except.Trans");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var DOM_XHR_Types = require("../DOM.XHR.Types");+var Data_Argonaut_Parser = require("../Data.Argonaut.Parser");+var Data_Array = require("../Data.Array");+var Data_Either = require("../Data.Either");+var Data_Eq = require("../Data.Eq");+var Data_Foldable = require("../Data.Foldable");+var Data_Foreign = require("../Data.Foreign");+var Data_Function = require("../Data.Function");+var Data_Function_Uncurried = require("../Data.Function.Uncurried");+var Data_Functor = require("../Data.Functor");+var Data_HTTP_Method = require("../Data.HTTP.Method");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Identity = require("../Data.Identity");+var Data_Int = require("../Data.Int");+var Data_List_Types = require("../Data.List.Types");+var Data_Maybe = require("../Data.Maybe");+var Data_MediaType = require("../Data.MediaType");+var Data_Nullable = require("../Data.Nullable");+var Data_Ring = require("../Data.Ring");+var Data_Semiring = require("../Data.Semiring");+var Data_Show = require("../Data.Show");+var Data_Time_Duration = require("../Data.Time.Duration");+var Data_Tuple = require("../Data.Tuple");+var $$Math = require("../Math");+var Network_HTTP_Affjax_Request = require("../Network.HTTP.Affjax.Request");+var Network_HTTP_Affjax_Response = require("../Network.HTTP.Affjax.Response");+var Network_HTTP_RequestHeader = require("../Network.HTTP.RequestHeader");+var Network_HTTP_ResponseHeader = require("../Network.HTTP.ResponseHeader");+var Network_HTTP_StatusCode = require("../Network.HTTP.StatusCode");+var Prelude = require("../Prelude");+var retry = function (dictRequestable) {+ return function (policy) {+ return function (run) {+ return function (req) {+ var retryState = function (v) {+ if (v instanceof Data_Either.Left) {+ return Data_Either.Left.create(new Data_Either.Left(v.value0));+ };+ if (v instanceof Data_Either.Right) {+ if (v.value0.status === 200) {+ return new Data_Either.Right(v.value0);+ };+ var $49 = policy.shouldRetryWithStatusCode(v.value0.status);+ if ($49) {+ return Data_Either.Left.create(new Data_Either.Right(v.value0));+ };+ return new Data_Either.Right(v.value0);+ };+ throw new Error("Failed pattern match at Network.HTTP.Affjax line 217, column 5 - line 217, column 44: " + [ v.constructor.name ]);+ };+ var go = function (failureRef) {+ return function (n) {+ return Control_Bind.bind(Control_Monad_Aff.bindAff)(Data_Functor.map(Control_Monad_Aff.functorAff)(retryState)(Control_Monad_Aff.attempt(run(req))))(function (v) {+ if (v instanceof Data_Either.Left) {+ return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Control_Monad_Eff_Ref.writeRef(failureRef)(new Data_Maybe.Just(v.value0))))(function () {+ return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Aff.bindAff)(Control_Monad_Aff.delay(policy.delayCurve(n)))(function () {+ return go(failureRef)(n + 1 | 0);+ });+ });+ };+ if (v instanceof Data_Either.Right) {+ return Control_Applicative.pure(Control_Monad_Aff.applicativeAff)(v.value0);+ };+ throw new Error("Failed pattern match at Network.HTTP.Affjax line 229, column 7 - line 234, column 32: " + [ v.constructor.name ]);+ });+ };+ };+ return Control_Bind.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Control_Monad_Eff_Ref.newRef(Data_Maybe.Nothing.value)))(function (v) {+ var loop = go(v);+ if (policy.timeout instanceof Data_Maybe.Nothing) {+ return loop(1);+ };+ if (policy.timeout instanceof Data_Maybe.Just) {+ return Control_Bind.bind(Control_Monad_Aff.bindAff)(Control_Monad_Aff_AVar.makeVar)(function (v1) {+ return Control_Bind.bind(Control_Monad_Aff.bindAff)(Control_Monad_Aff.forkAff(Control_Bind.bind(Control_Monad_Aff.bindAff)(loop(1))(function ($104) {+ return Control_Monad_Aff_AVar.putVar(v1)(Data_Maybe.Just.create($104));+ })))(function (v2) {+ return Control_Bind.bind(Control_Monad_Aff.bindAff)(Control_Monad_Aff.forkAff(Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Aff.bindAff)(Control_Monad_Aff.delay(policy.timeout.value0))(function () {+ return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Aff.bindAff)(Control_Monad_Aff_AVar.putVar(v1)(Data_Maybe.Nothing.value))(function () {+ return Control_Monad_Aff.cancel(v2)(Control_Monad_Eff_Exception.error("Cancel"));+ });+ })))(function (v3) {+ return Control_Bind.bind(Control_Monad_Aff.bindAff)(Control_Monad_Aff_AVar.takeVar(v1))(function (v4) {+ if (v4 instanceof Data_Maybe.Nothing) {+ return Control_Bind.bind(Control_Monad_Aff.bindAff)(Control_Monad_Eff_Class.liftEff(Control_Monad_Aff.monadEffAff)(Control_Monad_Eff_Ref.readRef(v)))(function (v5) {+ if (v5 instanceof Data_Maybe.Nothing) {+ return Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadThrowAff)(Control_Monad_Eff_Exception.error("Timeout"));+ };+ if (v5 instanceof Data_Maybe.Just) {+ return Data_Either.either(Control_Monad_Error_Class.throwError(Control_Monad_Aff.monadThrowAff))(Control_Applicative.pure(Control_Monad_Aff.applicativeAff))(v5.value0);+ };+ throw new Error("Failed pattern match at Network.HTTP.Affjax line 209, column 11 - line 211, column 61: " + [ v5.constructor.name ]);+ });+ };+ if (v4 instanceof Data_Maybe.Just) {+ return Control_Applicative.pure(Control_Monad_Aff.applicativeAff)(v4.value0);+ };+ throw new Error("Failed pattern match at Network.HTTP.Affjax line 206, column 7 - line 212, column 31: " + [ v4.constructor.name ]);+ });+ });+ });+ });+ };+ throw new Error("Failed pattern match at Network.HTTP.Affjax line 195, column 3 - line 212, column 31: " + [ policy.timeout.constructor.name ]);+ });+ };+ };+ };+};+var defaultRetryPolicy = {+ timeout: Data_Maybe.Nothing.value, + delayCurve: function (n) {+ return Data_Time_Duration.Milliseconds($$Math.max(30.0 * 1000.0)(100.0 * $$Math.pow(2.0)(Data_Int.toNumber(n - 1 | 0))));+ }, + shouldRetryWithStatusCode: Data_Function["const"](false)+};+var defaultRequest = {+ method: new Data_Either.Left(Data_HTTP_Method.GET.value), + url: "/", + headers: [ ], + content: Data_Maybe.Nothing.value, + username: Data_Maybe.Nothing.value, + password: Data_Maybe.Nothing.value, + withCredentials: false+};+var cancelAjax = function (xhr) {+ return function (err) {+ return Control_Monad_Aff.makeAff(function (eb) {+ return function (cb) {+ return $foreign._cancelAjax(xhr, err, eb, cb);+ };+ });+ };+};+var affjax$prime = function (dictRequestable) {+ return function (dictRespondable) {+ return function (req) {+ return function (eb) {+ return function (cb) {+ var responseSettings = Network_HTTP_Affjax_Response.responseType(dictRespondable);+ var requestSettings = (function () {+ var v = Data_Functor.map(Data_Maybe.functorMaybe)(Network_HTTP_Affjax_Request.toRequest(dictRequestable))(req.content);+ if (v instanceof Data_Maybe.Nothing) {+ return new Data_Tuple.Tuple(Data_Maybe.Nothing.value, Data_Maybe.Nothing.value);+ };+ if (v instanceof Data_Maybe.Just) {+ return new Data_Tuple.Tuple(v.value0.value0, new Data_Maybe.Just(v.value0.value1));+ };+ throw new Error("Failed pattern match at Network.HTTP.Affjax line 262, column 21 - line 264, column 49: " + [ v.constructor.name ]);+ })();+ var parseJSON = function ($105) {+ return Data_Either.either(function ($106) {+ return Data_Foreign.fail(Data_Foreign.JSONError.create($106));+ })(function ($107) {+ return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_Foreign.toForeign($107));+ })(Data_Argonaut_Parser.jsonParser($105));+ };+ var fromResponse$prime = (function () {+ var v = Data_Tuple.snd(responseSettings);+ if (v instanceof Network_HTTP_Affjax_Response.JSONResponse) {+ return Control_Bind.composeKleisliFlipped(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Network_HTTP_Affjax_Response.fromResponse(dictRespondable))(Control_Bind.composeKleisliFlipped(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(parseJSON)(Data_Foreign.readString));+ };+ return Network_HTTP_Affjax_Response.fromResponse(dictRespondable);+ })();+ var cb$prime = function (res) {+ var v = Data_Functor.map(Data_Either.functorEither)(function (v1) {+ var $72 = {};+ for (var $73 in res) {+ if ({}.hasOwnProperty.call(res, $73)) {+ $72[$73] = res[$73];+ };+ };+ $72.response = v1;+ return $72;+ })(Control_Monad_Except.runExcept(fromResponse$prime(res.response)));+ if (v instanceof Data_Either.Left) {+ return eb(Control_Monad_Eff_Exception.error(Data_Show.show(Data_List_Types.showNonEmptyList(Data_Foreign.showForeignError))(v.value0)));+ };+ if (v instanceof Data_Either.Right) {+ return cb(v.value0);+ };+ throw new Error("Failed pattern match at Network.HTTP.Affjax line 281, column 13 - line 283, column 26: " + [ v.constructor.name ]);+ };+ var addHeader = function (mh) {+ return function (hs) {+ if (mh instanceof Data_Maybe.Just && !Data_Foldable.any(Data_Foldable.foldableArray)(Data_HeytingAlgebra.heytingAlgebraBoolean)(Data_Function.on(Data_Eq.eq(Data_Eq.eqString))(Network_HTTP_RequestHeader.requestHeaderName)(mh.value0))(hs)) {+ return Data_Array.snoc(hs)(mh.value0);+ };+ return hs;+ };+ };+ var headers = addHeader(Data_Functor.map(Data_Maybe.functorMaybe)(Network_HTTP_RequestHeader.ContentType.create)(Data_Tuple.fst(requestSettings)))(addHeader(Data_Functor.map(Data_Maybe.functorMaybe)(Network_HTTP_RequestHeader.Accept.create)(Data_Tuple.fst(responseSettings)))(req.headers));+ var req$prime = {+ method: Data_HTTP_Method.print(req.method), + url: req.url, + headers: Data_Functor.map(Data_Functor.functorArray)(function (h) {+ return {+ field: Network_HTTP_RequestHeader.requestHeaderName(h), + value: Network_HTTP_RequestHeader.requestHeaderValue(h)+ };+ })(headers), + content: Data_Nullable.toNullable(Data_Tuple.snd(requestSettings)), + responseType: Network_HTTP_Affjax_Response.responseTypeToString(Data_Tuple.snd(responseSettings)), + username: Data_Nullable.toNullable(req.username), + password: Data_Nullable.toNullable(req.password), + withCredentials: req.withCredentials+ };+ return $foreign._ajax(Network_HTTP_ResponseHeader.responseHeader, req$prime, cancelAjax, eb, cb$prime);+ };+ };+ };+ };+};+var affjax = function (dictRequestable) {+ return function (dictRespondable) {+ return function ($108) {+ return Control_Monad_Aff["makeAff'"](affjax$prime(dictRequestable)(dictRespondable)($108));+ };+ };+};+var $$delete = function (dictRespondable) {+ return function (u) {+ return affjax(Network_HTTP_Affjax_Request.requestableUnit)(dictRespondable)((function () {+ var $80 = {};+ for (var $81 in defaultRequest) {+ if ({}.hasOwnProperty.call(defaultRequest, $81)) {+ $80[$81] = defaultRequest[$81];+ };+ };+ $80.method = new Data_Either.Left(Data_HTTP_Method.DELETE.value);+ $80.url = u;+ return $80;+ })());+ };+};+var delete_ = $$delete(Network_HTTP_Affjax_Response.responsableUnit);+var get = function (dictRespondable) {+ return function (u) {+ return affjax(Network_HTTP_Affjax_Request.requestableUnit)(dictRespondable)((function () {+ var $83 = {};+ for (var $84 in defaultRequest) {+ if ({}.hasOwnProperty.call(defaultRequest, $84)) {+ $83[$84] = defaultRequest[$84];+ };+ };+ $83.url = u;+ return $83;+ })());+ };+};+var patch = function (dictRequestable) {+ return function (dictRespondable) {+ return function (u) {+ return function (c) {+ return affjax(dictRequestable)(dictRespondable)((function () {+ var $86 = {};+ for (var $87 in defaultRequest) {+ if ({}.hasOwnProperty.call(defaultRequest, $87)) {+ $86[$87] = defaultRequest[$87];+ };+ };+ $86.method = new Data_Either.Left(Data_HTTP_Method.PATCH.value);+ $86.url = u;+ $86.content = new Data_Maybe.Just(c);+ return $86;+ })());+ };+ };+ };+};+var patch_ = function (dictRequestable) {+ return patch(dictRequestable)(Network_HTTP_Affjax_Response.responsableUnit);+};+var patch$prime = function (dictRequestable) {+ return function (dictRespondable) {+ return function (u) {+ return function (c) {+ return affjax(dictRequestable)(dictRespondable)((function () {+ var $89 = {};+ for (var $90 in defaultRequest) {+ if ({}.hasOwnProperty.call(defaultRequest, $90)) {+ $89[$90] = defaultRequest[$90];+ };+ };+ $89.method = new Data_Either.Left(Data_HTTP_Method.PATCH.value);+ $89.url = u;+ $89.content = c;+ return $89;+ })());+ };+ };+ };+};+var patch_$prime = function (dictRequestable) {+ return patch$prime(dictRequestable)(Network_HTTP_Affjax_Response.responsableUnit);+};+var post = function (dictRequestable) {+ return function (dictRespondable) {+ return function (u) {+ return function (c) {+ return affjax(dictRequestable)(dictRespondable)((function () {+ var $92 = {};+ for (var $93 in defaultRequest) {+ if ({}.hasOwnProperty.call(defaultRequest, $93)) {+ $92[$93] = defaultRequest[$93];+ };+ };+ $92.method = new Data_Either.Left(Data_HTTP_Method.POST.value);+ $92.url = u;+ $92.content = new Data_Maybe.Just(c);+ return $92;+ })());+ };+ };+ };+};+var post_ = function (dictRequestable) {+ return post(dictRequestable)(Network_HTTP_Affjax_Response.responsableUnit);+};+var post$prime = function (dictRequestable) {+ return function (dictRespondable) {+ return function (u) {+ return function (c) {+ return affjax(dictRequestable)(dictRespondable)((function () {+ var $95 = {};+ for (var $96 in defaultRequest) {+ if ({}.hasOwnProperty.call(defaultRequest, $96)) {+ $95[$96] = defaultRequest[$96];+ };+ };+ $95.method = new Data_Either.Left(Data_HTTP_Method.POST.value);+ $95.url = u;+ $95.content = c;+ return $95;+ })());+ };+ };+ };+};+var post_$prime = function (dictRequestable) {+ return post$prime(dictRequestable)(Network_HTTP_Affjax_Response.responsableUnit);+};+var put = function (dictRequestable) {+ return function (dictRespondable) {+ return function (u) {+ return function (c) {+ return affjax(dictRequestable)(dictRespondable)((function () {+ var $98 = {};+ for (var $99 in defaultRequest) {+ if ({}.hasOwnProperty.call(defaultRequest, $99)) {+ $98[$99] = defaultRequest[$99];+ };+ };+ $98.method = new Data_Either.Left(Data_HTTP_Method.PUT.value);+ $98.url = u;+ $98.content = new Data_Maybe.Just(c);+ return $98;+ })());+ };+ };+ };+};+var put_ = function (dictRequestable) {+ return put(dictRequestable)(Network_HTTP_Affjax_Response.responsableUnit);+};+var put$prime = function (dictRequestable) {+ return function (dictRespondable) {+ return function (u) {+ return function (c) {+ return affjax(dictRequestable)(dictRespondable)((function () {+ var $101 = {};+ for (var $102 in defaultRequest) {+ if ({}.hasOwnProperty.call(defaultRequest, $102)) {+ $101[$102] = defaultRequest[$102];+ };+ };+ $101.method = new Data_Either.Left(Data_HTTP_Method.PUT.value);+ $101.url = u;+ $101.content = c;+ return $101;+ })());+ };+ };+ };+};+var put_$prime = function (dictRequestable) {+ return put$prime(dictRequestable)(Network_HTTP_Affjax_Response.responsableUnit);+};+module.exports = {+ affjax: affjax, + "affjax'": affjax$prime, + defaultRequest: defaultRequest, + defaultRetryPolicy: defaultRetryPolicy, + "delete": $$delete, + delete_: delete_, + get: get, + patch: patch, + "patch'": patch$prime, + patch_: patch_, + "patch_'": patch_$prime, + post: post, + "post'": post$prime, + post_: post_, + "post_'": post_$prime, + put: put, + "put'": put$prime, + put_: put_, + "put_'": put_$prime, + retry: retry+};++},{"../Control.Applicative":40,"../Control.Bind":46,"../Control.Monad.Aff":55,"../Control.Monad.Aff.AVar":51,"../Control.Monad.Eff":70,"../Control.Monad.Eff.Class":58,"../Control.Monad.Eff.Exception":62,"../Control.Monad.Eff.Ref":66,"../Control.Monad.Error.Class":71,"../Control.Monad.Except":73,"../Control.Monad.Except.Trans":72,"../Control.Semigroupoid":92,"../DOM.XHR.Types":99,"../Data.Argonaut.Parser":111,"../Data.Array":119,"../Data.Either":136,"../Data.Eq":138,"../Data.Foldable":143,"../Data.Foreign":145,"../Data.Function":149,"../Data.Function.Uncurried":148,"../Data.Functor":155,"../Data.HTTP.Method":158,"../Data.HeytingAlgebra":160,"../Data.Identity":161,"../Data.Int":165,"../Data.List.Types":193,"../Data.Maybe":198,"../Data.MediaType":200,"../Data.Nullable":212,"../Data.Ring":227,"../Data.Semiring":231,"../Data.Show":233,"../Data.Time.Duration":242,"../Data.Tuple":245,"../Math":256,"../Network.HTTP.Affjax.Request":257,"../Network.HTTP.Affjax.Response":258,"../Network.HTTP.RequestHeader":261,"../Network.HTTP.ResponseHeader":262,"../Network.HTTP.StatusCode":263,"../Prelude":268,"./foreign":259}],261:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Data_Eq = require("../Data.Eq");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_MediaType = require("../Data.MediaType");+var Data_Newtype = require("../Data.Newtype");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Prelude = require("../Prelude");+var Accept = (function () {+ function Accept(value0) {+ this.value0 = value0;+ };+ Accept.create = function (value0) {+ return new Accept(value0);+ };+ return Accept;+})();+var ContentType = (function () {+ function ContentType(value0) {+ this.value0 = value0;+ };+ ContentType.create = function (value0) {+ return new ContentType(value0);+ };+ return ContentType;+})();+var RequestHeader = (function () {+ function RequestHeader(value0, value1) {+ this.value0 = value0;+ this.value1 = value1;+ };+ RequestHeader.create = function (value0) {+ return function (value1) {+ return new RequestHeader(value0, value1);+ };+ };+ return RequestHeader;+})();+var showRequestHeader = new Data_Show.Show(function (v) {+ if (v instanceof Accept) {+ return "(Accept " + (Data_Show.show(Data_MediaType.showMediaType)(v.value0) + ")");+ };+ if (v instanceof ContentType) {+ return "(ContentType " + (Data_Show.show(Data_MediaType.showMediaType)(v.value0) + ")");+ };+ if (v instanceof RequestHeader) {+ return "(RequestHeader " + (Data_Show.show(Data_Show.showString)(v.value0) + (" " + (Data_Show.show(Data_Show.showString)(v.value1) + ")")));+ };+ throw new Error("Failed pattern match at Network.HTTP.RequestHeader line 20, column 3 - line 21, column 3: " + [ v.constructor.name ]);+});+var requestHeaderValue = function (v) {+ if (v instanceof Accept) {+ return Data_Newtype.unwrap(Data_MediaType.newtypeMediaType)(v.value0);+ };+ if (v instanceof ContentType) {+ return Data_Newtype.unwrap(Data_MediaType.newtypeMediaType)(v.value0);+ };+ if (v instanceof RequestHeader) {+ return v.value1;+ };+ throw new Error("Failed pattern match at Network.HTTP.RequestHeader line 30, column 1 - line 30, column 41: " + [ v.constructor.name ]);+};+var requestHeaderName = function (v) {+ if (v instanceof Accept) {+ return "Accept";+ };+ if (v instanceof ContentType) {+ return "Content-Type";+ };+ if (v instanceof RequestHeader) {+ return v.value0;+ };+ throw new Error("Failed pattern match at Network.HTTP.RequestHeader line 25, column 1 - line 26, column 1: " + [ v.constructor.name ]);+};+var eqRequestHeader = new Data_Eq.Eq(function (v) {+ return function (v1) {+ if (v instanceof Accept && v1 instanceof Accept) {+ return Data_Eq.eq(Data_MediaType.eqMediaType)(v.value0)(v1.value0);+ };+ if (v instanceof ContentType && v1 instanceof ContentType) {+ return Data_Eq.eq(Data_MediaType.eqMediaType)(v.value0)(v1.value0);+ };+ if (v instanceof RequestHeader && v1 instanceof RequestHeader) {+ return v.value0 === v1.value0 && v.value1 === v1.value1;+ };+ return false;+ };+});+module.exports = {+ Accept: Accept, + ContentType: ContentType, + RequestHeader: RequestHeader, + requestHeaderName: requestHeaderName, + requestHeaderValue: requestHeaderValue, + eqRequestHeader: eqRequestHeader, + showRequestHeader: showRequestHeader+};++},{"../Data.Eq":138,"../Data.HeytingAlgebra":160,"../Data.MediaType":200,"../Data.Newtype":209,"../Data.Semigroup":229,"../Data.Show":233,"../Prelude":268}],262:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Apply = require("../Control.Apply");+var Data_Eq = require("../Data.Eq");+var Data_Generic = require("../Data.Generic");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_Maybe = require("../Data.Maybe");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var ResponseHeader = (function () {+ function ResponseHeader(value0, value1) {+ this.value0 = value0;+ this.value1 = value1;+ };+ ResponseHeader.create = function (value0) {+ return function (value1) {+ return new ResponseHeader(value0, value1);+ };+ };+ return ResponseHeader;+})();+var showResponseHeader = new Data_Show.Show(function (v) {+ return "(ResponseHeader " + (Data_Show.show(Data_Show.showString)(v.value0) + (" " + (Data_Show.show(Data_Show.showString)(v.value1) + ")")));+});+var responseHeaderValue = function (v) {+ return v.value1;+};+var responseHeaderName = function (v) {+ return v.value0;+};+var responseHeader = function (field) {+ return function (value) {+ return new ResponseHeader(field, value);+ };+};+var genericResponseHeader = new Data_Generic.Generic(function (v) {+ if (v instanceof Data_Generic.SProd && (v.value0 === "Network.HTTP.ResponseHeader.ResponseHeader" && v.value1.length === 2)) {+ return Control_Apply.apply(Data_Maybe.applyMaybe)(Control_Apply.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(ResponseHeader.create))(Data_Generic.fromSpine(Data_Generic.genericString)(v["value1"][0](Data_Unit.unit))))(Data_Generic.fromSpine(Data_Generic.genericString)(v["value1"][1](Data_Unit.unit)));+ };+ return Data_Maybe.Nothing.value;+}, function ($dollarq) {+ return new Data_Generic.SigProd("Network.HTTP.ResponseHeader.ResponseHeader", [ {+ sigConstructor: "Network.HTTP.ResponseHeader.ResponseHeader", + sigValues: [ function ($dollarq1) {+ return Data_Generic.toSignature(Data_Generic.genericString)(Data_Generic.anyProxy);+ }, function ($dollarq1) {+ return Data_Generic.toSignature(Data_Generic.genericString)(Data_Generic.anyProxy);+ } ]+ } ]);+}, function (v) {+ return new Data_Generic.SProd("Network.HTTP.ResponseHeader.ResponseHeader", [ function ($dollarq) {+ return Data_Generic.toSpine(Data_Generic.genericString)(v.value0);+ }, function ($dollarq) {+ return Data_Generic.toSpine(Data_Generic.genericString)(v.value1);+ } ]);+});+var eqResponseHeader = new Data_Eq.Eq(function (v) {+ return function (v1) {+ return v.value0 === v1.value0 && v.value1 === v1.value1;+ };+});+module.exports = {+ responseHeader: responseHeader, + responseHeaderName: responseHeaderName, + responseHeaderValue: responseHeaderValue, + genericResponseHeader: genericResponseHeader, + eqResponseHeader: eqResponseHeader, + showResponseHeader: showResponseHeader+};++},{"../Control.Apply":42,"../Data.Eq":138,"../Data.Generic":157,"../Data.HeytingAlgebra":160,"../Data.Maybe":198,"../Data.Semigroup":229,"../Data.Show":233,"../Data.Unit":249,"../Prelude":268}],263:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Apply = require("../Control.Apply");+var Data_Eq = require("../Data.Eq");+var Data_Generic = require("../Data.Generic");+var Data_Maybe = require("../Data.Maybe");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Show = require("../Data.Show");+var Data_Unit = require("../Data.Unit");+var Prelude = require("../Prelude");+var StatusCode = function (x) {+ return x;+};+var showStatusCode = new Data_Show.Show(function (v) {+ return "(StatusCode " + (Data_Show.show(Data_Show.showInt)(v) + ")");+});+var genericStatusCode = new Data_Generic.Generic(function (v) {+ if (v instanceof Data_Generic.SProd && (v.value0 === "Network.HTTP.StatusCode.StatusCode" && v.value1.length === 1)) {+ return Control_Apply.apply(Data_Maybe.applyMaybe)(new Data_Maybe.Just(StatusCode))(Data_Generic.fromSpine(Data_Generic.genericInt)(v["value1"][0](Data_Unit.unit)));+ };+ return Data_Maybe.Nothing.value;+}, function ($dollarq) {+ return new Data_Generic.SigProd("Network.HTTP.StatusCode.StatusCode", [ {+ sigConstructor: "Network.HTTP.StatusCode.StatusCode", + sigValues: [ function ($dollarq1) {+ return Data_Generic.toSignature(Data_Generic.genericInt)(Data_Generic.anyProxy);+ } ]+ } ]);+}, function (v) {+ return new Data_Generic.SProd("Network.HTTP.StatusCode.StatusCode", [ function ($dollarq) {+ return Data_Generic.toSpine(Data_Generic.genericInt)(v);+ } ]);+});+var eqStatusCode = new Data_Eq.Eq(function (v) {+ return function (v1) {+ return v === v1;+ };+});+module.exports = {+ StatusCode: StatusCode, + genericStatusCode: genericStatusCode, + eqStatusCode: eqStatusCode, + showStatusCode: showStatusCode+};++},{"../Control.Apply":42,"../Data.Eq":138,"../Data.Generic":157,"../Data.Maybe":198,"../Data.Semigroup":229,"../Data.Show":233,"../Data.Unit":249,"../Prelude":268}],264:[function(require,module,exports){+"use strict";++// module Partial.Unsafe++exports.unsafePartial = function (f) {+ return f();+};++exports.unsafePartialBecause = function (reason) {+ return function (f) {+ try {+ return exports.unsafePartial(f);+ } catch (err) {+ throw new Error("unsafePartial failed. The following " ++ "assumption was incorrect: '" + reason + "'.");+ }+ };+};++},{}],265:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var Partial = require("../Partial");+var unsafeCrashWith = function (msg) {+ return $foreign.unsafePartial(function (dictPartial) {+ return Partial.crashWith(dictPartial)(msg);+ });+};+module.exports = {+ unsafeCrashWith: unsafeCrashWith, + unsafePartial: $foreign.unsafePartial, + unsafePartialBecause: $foreign.unsafePartialBecause+};++},{"../Partial":267,"./foreign":264}],266:[function(require,module,exports){+"use strict";++// module Partial++exports.crashWith = function () {+ return function (msg) {+ throw new Error(msg);+ };+};++},{}],267:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+var crash = function (dictPartial) {+ return $foreign.crashWith(dictPartial)("Partial.crash: partial function");+};+module.exports = {+ crash: crash, + crashWith: $foreign.crashWith+};++},{"./foreign":266}],268:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Control_Applicative = require("../Control.Applicative");+var Control_Apply = require("../Control.Apply");+var Control_Bind = require("../Control.Bind");+var Control_Category = require("../Control.Category");+var Control_Monad = require("../Control.Monad");+var Control_Semigroupoid = require("../Control.Semigroupoid");+var Data_Boolean = require("../Data.Boolean");+var Data_BooleanAlgebra = require("../Data.BooleanAlgebra");+var Data_Bounded = require("../Data.Bounded");+var Data_CommutativeRing = require("../Data.CommutativeRing");+var Data_Eq = require("../Data.Eq");+var Data_EuclideanRing = require("../Data.EuclideanRing");+var Data_Field = require("../Data.Field");+var Data_Function = require("../Data.Function");+var Data_Functor = require("../Data.Functor");+var Data_HeytingAlgebra = require("../Data.HeytingAlgebra");+var Data_NaturalTransformation = require("../Data.NaturalTransformation");+var Data_Ord = require("../Data.Ord");+var Data_Ordering = require("../Data.Ordering");+var Data_Ring = require("../Data.Ring");+var Data_Semigroup = require("../Data.Semigroup");+var Data_Semiring = require("../Data.Semiring");+var Data_Show = require("../Data.Show");+var Data_Unit = require("../Data.Unit");+var Data_Void = require("../Data.Void");+module.exports = {};++},{"../Control.Applicative":40,"../Control.Apply":42,"../Control.Bind":46,"../Control.Category":47,"../Control.Monad":86,"../Control.Semigroupoid":92,"../Data.Boolean":129,"../Data.BooleanAlgebra":130,"../Data.Bounded":132,"../Data.CommutativeRing":133,"../Data.Eq":138,"../Data.EuclideanRing":140,"../Data.Field":141,"../Data.Function":149,"../Data.Functor":155,"../Data.HeytingAlgebra":160,"../Data.NaturalTransformation":208,"../Data.Ord":216,"../Data.Ordering":217,"../Data.Ring":227,"../Data.Semigroup":229,"../Data.Semiring":231,"../Data.Show":233,"../Data.Unit":249,"../Data.Void":250}],269:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var Proxy3 = (function () {+ function Proxy3() {++ };+ Proxy3.value = new Proxy3();+ return Proxy3;+})();+var Proxy2 = (function () {+ function Proxy2() {++ };+ Proxy2.value = new Proxy2();+ return Proxy2;+})();+var $$Proxy = (function () {+ function $$Proxy() {++ };+ $$Proxy.value = new $$Proxy();+ return $$Proxy;+})();+module.exports = {+ "Proxy": $$Proxy, + Proxy2: Proxy2, + Proxy3: Proxy3+};++},{}],270:[function(require,module,exports){+"use strict";++// module Unsafe.Coerce++exports.unsafeCoerce = function (x) {+ return x;+};++},{}],271:[function(require,module,exports){+// Generated by purs version 0.11.3+"use strict";+var $foreign = require("./foreign");+module.exports = {+ unsafeCoerce: $foreign.unsafeCoerce+};++},{"./foreign":270}],272:[function(require,module,exports){+require('Main').main();++},{"Main":254}],273:[function(require,module,exports){+// shim for using process in browser+var process = module.exports = {};++// cached from whatever global is present so that test runners that stub it+// don't break things. But we need to wrap it in a try catch in case it is+// wrapped in strict mode code which doesn't define any globals. It's inside a+// function because try/catches deoptimize in certain engines.++var cachedSetTimeout;+var cachedClearTimeout;++function defaultSetTimout() {+ throw new Error('setTimeout has not been defined');+}+function defaultClearTimeout () {+ throw new Error('clearTimeout has not been defined');+}+(function () {+ try {+ if (typeof setTimeout === 'function') {+ cachedSetTimeout = setTimeout;+ } else {+ cachedSetTimeout = defaultSetTimout;+ }+ } catch (e) {+ cachedSetTimeout = defaultSetTimout;+ }+ try {+ if (typeof clearTimeout === 'function') {+ cachedClearTimeout = clearTimeout;+ } else {+ cachedClearTimeout = defaultClearTimeout;+ }+ } catch (e) {+ cachedClearTimeout = defaultClearTimeout;+ }+} ())+function runTimeout(fun) {+ if (cachedSetTimeout === setTimeout) {+ //normal enviroments in sane situations+ return setTimeout(fun, 0);+ }+ // if setTimeout wasn't available but was latter defined+ if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {+ cachedSetTimeout = setTimeout;+ return setTimeout(fun, 0);+ }+ try {+ // when when somebody has screwed with setTimeout but no I.E. maddness+ return cachedSetTimeout(fun, 0);+ } catch(e){+ try {+ // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally+ return cachedSetTimeout.call(null, fun, 0);+ } catch(e){+ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error+ return cachedSetTimeout.call(this, fun, 0);+ }+ }+++}+function runClearTimeout(marker) {+ if (cachedClearTimeout === clearTimeout) {+ //normal enviroments in sane situations+ return clearTimeout(marker);+ }+ // if clearTimeout wasn't available but was latter defined+ if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {+ cachedClearTimeout = clearTimeout;+ return clearTimeout(marker);+ }+ try {+ // when when somebody has screwed with setTimeout but no I.E. maddness+ return cachedClearTimeout(marker);+ } catch (e){+ try {+ // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally+ return cachedClearTimeout.call(null, marker);+ } catch (e){+ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.+ // Some versions of I.E. have different rules for clearTimeout vs setTimeout+ return cachedClearTimeout.call(this, marker);+ }+ }++++}+var queue = [];+var draining = false;+var currentQueue;+var queueIndex = -1;++function cleanUpNextTick() {+ if (!draining || !currentQueue) {+ return;+ }+ draining = false;+ if (currentQueue.length) {+ queue = currentQueue.concat(queue);+ } else {+ queueIndex = -1;+ }+ if (queue.length) {+ drainQueue();+ }+}++function drainQueue() {+ if (draining) {+ return;+ }+ var timeout = runTimeout(cleanUpNextTick);+ draining = true;++ var len = queue.length;+ while(len) {+ currentQueue = queue;+ queue = [];+ while (++queueIndex < len) {+ if (currentQueue) {+ currentQueue[queueIndex].run();+ }+ }+ queueIndex = -1;+ len = queue.length;+ }+ currentQueue = null;+ draining = false;+ runClearTimeout(timeout);+}++process.nextTick = function (fun) {+ var args = new Array(arguments.length - 1);+ if (arguments.length > 1) {+ for (var i = 1; i < arguments.length; i++) {+ args[i - 1] = arguments[i];+ }+ }+ queue.push(new Item(fun, args));+ if (queue.length === 1 && !draining) {+ runTimeout(drainQueue);+ }+};++// v8 likes predictible objects+function Item(fun, array) {+ this.fun = fun;+ this.array = array;+}+Item.prototype.run = function () {+ this.fun.apply(null, this.array);+};+process.title = 'browser';+process.browser = true;+process.env = {};+process.argv = [];+process.version = ''; // empty string to avoid regexp issues+process.versions = {};++function noop() {}++process.on = noop;+process.addListener = noop;+process.once = noop;+process.off = noop;+process.removeListener = noop;+process.removeAllListeners = noop;+process.emit = noop;++process.binding = function (name) {+ throw new Error('process.binding is not supported');+};++process.cwd = function () { return '/' };+process.chdir = function (dir) {+ throw new Error('process.chdir is not supported');+};+process.umask = function() { return 0; };++},{}]},{},[272]);
+ yesod-auth-hmac-keccak.cabal view
@@ -0,0 +1,60 @@+-- Initial yesod-auth-hmac-keccak.cabal generated by cabal init. For +-- further documentation, see http://haskell.org/cabal/users-guide/++name: yesod-auth-hmac-keccak+version: 0.0.0.1+synopsis: An account authentication plugin for yesod with encrypted+ token transfer.+description: This authentication plugin for Yesod uses a challenge-response+ authentication mechanism, where the password is encrypted via HMAC-+ Keccak on the client side.+license: MIT+license-file: LICENSE+author: nek0+maintainer: nek0@chelnok.de+-- copyright: +category: Web+build-type: Custom+extra-source-files: ChangeLog.md+cabal-version: >=1.10+extra-source-files: src/Activate.purs+ , src/Common.js+ , src/Common.purs+ , src/Login.purs+ , src/Main.purs+ , bower.json+data-files: static/js/auth.js++Source-repository head+ type: git+ location: git://github.com/nek0/yesod-auth-hmac-keccak.git++library+ exposed-modules: Yesod.Auth.HmacKeccak+ Yesod.Auth.Message+ , Yesod.Auth.Import+ , Yesod.Auth.Types+ other-modules: Paths_yesod_auth_hmac_keccak+ , Yesod.Auth.JsPath+ -- other-extensions: + default-extensions: OverloadedStrings+ ghc-options: -Wall+ build-depends: base >=4.9 && <4.10+ , text+ , bytestring+ , aeson+ , cryptonite+ , yesod-core+ , yesod-form+ , yesod-auth+ , yesod-static+ , yesod-persistent+ , persistent+ , random+ , mtl+ , shakespeare+ -- dependencies for purescript and compiling+ -- , purescript+ -- , Glob+ hs-source-dirs: hssrc+ default-language: Haskell2010