Tk'7      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                    !!"##$$$$%&&&&&&&&&&&&&&& & & & & &&&&&&&&&&&''()*+++ ,!,",#,$,%,&,'-(-)-*.+/,0-1.1/1011121314151615 Safe-InferredState for the parser monad +The most recently marked indentation level  Safe-Inferred Safe-Inferred70Data type for simplified Javascript expressions WRaw Javascript (generated when parsing fails for an inline foreign import declaration) Continue statement Break statement Labelled statement InstanceOf test Type-Of operator Throw statement Return statement If-then-else statement  ForIn loop  For loop  While loop A variable assignment 4A variable introduction and optional initialization !A block of expressions in braces Conditional expression  Variable Function application 9A function introduction (optional name, arguments, body) 'An object property accessor expression An object literal An array indexer expression An array literal A binary operator application !A unary operator application "A boolean literal #A string literal $A numeric literal %Built-in binary operators &#Bitwise right shift with zero-fill 'Bitwise right shift (Bitwise left shift ) Bitwise xor * Bitwise or + Bitwise and , Boolean or - Boolean and .Numeric greater-than-or-equal /Numeric greater-than 0Numeric less-than-or-equal 1Numeric less-than 2Generic inequality test 3Generic equality test 4 Remainder 5Numeric division 6Numeric multiplication 7Numeric subtraction 8Numeric addition 9Built-in unary operators : Constructor ;Numeric unary 'plus' <Bitwise negation =Boolean negation >Numeric negation :  !"#$%&'()*+,-./0123456789:;<=>?@A:  !"#$%&'()*+,-./0123456789:;<=>?@A:9>=<;:%876543210/.-,+*)('&$#"!  ?@A$#"!  %876543210/.-,+*)('&9>=<;:?@A Safe-Inferred BCDEFGHIJ BCDEFGHIJ BCDEFGHIJ BCDEFGHIJ Safe-InferredKACollapse blocks which appear nested directly below another block KLKLKLKL2 Safe-Inferred 789:;<=>?@ABC8>?@ABC 789:;<=>?@ABC Safe-InferredBMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~BMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~BMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~BMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-InferredNone D D  Safe-Inferred "The data type of compiler options *Disable inclusion of the built in Prelude Disable tail-call elimination ?Disable inlining of calls to return and bind for the Eff monad #When specified, checks the type of main0 in the module, and generate a call to run main  after the module definitions. Skip all optimizations Verbose error message VSpecify the namespace that PureScript modules will be exported to when running in the  browser. Per-mode options WIndicates the mode of the compiler. Lifted using DataKinds to refine the Options type. Default compiler options Default make options   Safe-InferredEliminate tail calls EE  Safe-Inferred;A qualified name, i.e. a name with an optional module name  Module names @Proper names, i.e. capitalized names for e.g. module names, typedata constructors. Names for value identifiers &A symbolic name for an infix operator An alphanumeric identifier 8Provide a default module name, if a name is unqualified FGHI FGHI  Safe-Inferred0*A list of purescript reserved identifiers ,The characters allowed for use in operators )A list of reserved identifiers for types A list of reserved operators )Valid first characters for an identifier Valid identifier characters 'Valid first characters for an operator Valid operators characters #The PureScript language definition 0A token parser based on the language definition Parse a token Parse an identifier Parse a reserved word Parse a reserved operator Parse an operator Parse a string literal Parse whitespace  Semicolon Colon Period Comma  Backtick Pipe character Natural number Parse a proper name Parse a module name 1Parse a qualified name, i.e. M.name or just name )Parse an integer or floating point value .Parse an identifier or parenthesized operator %Parse a token inside square brackets !Parse a token inside parentheses Parse a token inside braces $Parse a token inside angle brackets 9Parse zero or more values separated by a separator token 8Parse one or more values separated by a separator token 2Parse zero or more values separated by semicolons 1Parse one or more values separated by semicolons .Parse zero or more values separated by commas -Parse one or more values separated by commas oRun the first parser, then match the second if possible, applying the specified function on a successful match oRun the first parser, then match the second zero or more times, applying the specified function for each match QBuild a parser from a smaller parser and a list of parsers for postfix operators 0Parse an identifier in backticks or an operator #Mark the current indentation level <Check that the current identation level matches a predicate BCheck that the current indentation level is past the current mark XCheck that the current indentation level is at the same indentation as the current mark (Run a parser which supports indentation 0000  Safe-InferredWrap a string in parentheses *Number of characters per identation level *Pretty print with a new indentation level "Get the current indentation level Print many lines /Prints an object key, escaping reserved names. NoneThe data type of kinds Function kinds 6Kinds for labelled, unordered rows without duplicates The kind of effects The kind of types "Unification variable of type Kind None Parse a kind JKLJKLNone5Generate a pretty-printed string representing a Kind MNOMNONoneThe type of types &A placeholder used in pretty printing &A placeholder used in pretty printing &A placeholder used in pretty printing &A placeholder used in pretty printing A type with a kind annotation A non-empty row   An empty row  A skolem constant  ,A type with a set of type class constraints  Forall quantifier  A type synonym which is " saturated", i.e. fully applied A type application A type constructor A named type variable $A unification variable of type Type 1An identifier for the scope of a skolem variable 5Convert a row to a list of pairs of labels and types ,Convert a list of labels and types to a row #Check whether a type is a monotype Universally quantify a type @Replace a type variable, taking into account variable shadowing (Replace named type variables with types /Collect all type variables appearing in a type 4Collect all free type variables appearing in a type FUniversally quantify over all type variables appearing free in a type 6Move all universal quantifiers to the front of a type "      !"#"      !"#"      !"#      !"#None $$The type of a type class dictionary %YA type class dictionary which is an alias for an imported dictionary from another module & A regular type class dictionary '<Data representing a type class dictionary which is in scope )DThe identifier with which the dictionary can be accessed at runtime *EThe name of the type class to which this type class instance applies +4The types to which this type class instance applies ,MType class dependencies which must be satisfied to construct this dictionary -The type of this dictionary .)Is this instance exported by its module? $%&'()*+,-. $%&'()*+,-. '()*+,-.$&%$&%'()*+,-.None'/ The type ('data' or  'newtype') of a data type declaration 0A newtype constructor 1A standard data constructor 2The kinds of a type 3A local type variable 4 Foreign data 5 Type synonym 6 Data type 7The kind of a name 8PA type class dictionary, generated during desugaring of type class declarations 9A data constructor :TA local name introduced using a lambda abstraction, variable introduction or binder ;A foreign import <gA type class dictionary member accessor import, generated during desugaring of type class declarations =,A value introduced as a binding in a module >"The visibility of a name in scope ?`The name is defined in the another binding group, or has been made visible by a function binder @EThe name is defined in the current binding group, but is not visible AThe type of a foreign import BFA foreign import which contains inline Javascript as a string literal CA regular foreign import DThe  Environment< defines all values and types which are currently in scope: FValue names currently in scope GType names currently in scope HYData constructors currently in scope, along with their associated data type constructors I!Type synonyms currently in scope J"Available type class dictionaries K Type classes LUThe initial environment with no values and only the default javascript types defined M*Construct a ProperName in the Prim module N$Construct a type in the Prim module OType constructor for functions PType constructor for strings QType constructor for numbers RType constructor for booleans SType constructor for arrays TType constructor for objects U%Smart constructor for function types VXThe primitive types in the external javascript environment with their associated kinds. )/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVP(/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV(DEFGHIJKLACB>@?7=<;:9826543/10MNOPQRSTUV/10265437=<;:98>@?ACBDEFGHIJKLMNOPQRSTUVPNoneYWData type for binders X*A binder with source position information Y0A binder which binds its input to an identifier Z<A binder which matches an array and binds its head and tail [7A binder which matches an array and binds its elements \9A binder which matches a record and binds its properties ]*A binder which matches a data constructor ^#A binder which binds an identifier _)A binder which matches a numeric literal `(A binder which matches a string literal a)A binder which matches a boolean literal bWildcard binder c#A statement in a do-notation block d7A do notation element with source position information e1A let statement, i.e. a pure value with a binder fA monadic value with a binder g!A monadic value without a binder h#An alternative in a case statement j7A collection of binders with which to match the inputs kAn optional guard lThe result expression m$Data type for expressions and terms n)A value with source position information ofA placeholder for a superclass dictionary to be turned into a TypeClassDictionary during typechecking pcA placeholder for a type class dictionary to be inserted later. At the end of type checking, these d placeholders will be replaced with actual expressions representing type classes dictionaries which e can be evaluated at runtime. The constructor arguments represent (in order): whether or not to look X at superclass implementations when searching for a dictionary, the type class name and : instance type, and the type class dictionaries in scope. qJAn application of a typeclass dictionary constructor. The value should be  an ObjectLiteral. rA do-notation block sA let binding tA value with a type annotation u]A case expression. During the case expansion phase of desugaring, top-level binders will get b desugared into case expressions, hence the need for guards and multiple binders per branch here. vA data constructor w&Conditional (if-then-else expression) x Variable yFunction application zFunction introduction {Partial record update |'An record property accessor expression }An object literal ~An array literal YExplicit parentheses. During the rebracketing phase of desugaring, this data constructor  will be removed. `Binary operator application. During the rebracketing phase of desugaring, this data constructor  will be removed. A prefix -, will be desugared A boolean literal A string literal A numeric literal TA guard is just a boolean-valued expression that appears alongside a set of binders The data type of declarations /A declaration with source position information TA type instance declaration (name, dependencies, class name, instance types, member  declarations) HA type class declaration (name, argument, implies, member declarations) EA module import (module name, optional set of identifiers to import, / optional set of identifiers to hide, optional  qualified as name) 2A fixity declaration (fixity data, operator name) %A type class instance foreign import (A data type foreign import (name, kind) LA foreign import declaration (type, name, optional inline Javascript, type) 7A minimal mutually recursive set of value declarations EA value declaration (name, top-level binders, optional guard, value) *A type declaration for a value (name, ty) 3A type synonym declaration (name, arguments, type) ;A minimal mutually recursive set of data type declarations NA data type declaration (data or newtype, name, arguments, data constructors) 9The data type which specifies type of import declaration <Import with hiding clause with a list of references to hide 5Qualified import with a list of references to import Unqualified import 1An item in a list of explicit imports or exports 9A declaration reference with source position information ^A type class instance, created during typeclass desugaring (name, class name, instance types)  A type class A value *A type constructor with data constructors ]A module declaration, consisting of a module name, a list of declarations, and a list of the c declarations that are explicitly exported. If the export list is Nothing, everything is exported.  Fixity data for infix operators Source position information  Source name  Line number Column number "Associativity for infix operators )A precedence level for an infix operator -Test if a declaration is a value declaration ATest if a declaration is a data type or type synonym declaration )Test if a declaration is a module import 4Test if a declaration is a data type foreign import >Test if a declaration is a type class instance foreign import .Test if a declaration is a fixity declaration *Test if a declaration is a foreign import >Test if a declaration is a type class or instance declaration NFind the original dictionary which a type class dictionary in scope refers to 9Collect all names introduced in binders in an expression jWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~QRSgWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~gm~}|{zyxwvutsrqponhijklcgfedWba`_^]\[ZYX!W ba`_^]\[ZYXcgfedhijklm~}|{zyxwvutsrqponQRSNone*A list of modules with their dependencies ;Sort a collection of modules based on module dependencies. 7Reports an error if the module graph contains a cycle. TOCalculate a list of used modules based on explicit imports and qualified names UGConvert a strongly connected component of the module graph to a module TVUTVUNone[Eliminate all declarations which are not a transitive dependency of the entry point module WXYZWXYZNone 5Convert an Ident into a valid Javascript identifier: . Alphanumeric characters are kept unmodified. 3 Reserved javascript identifiers are prefixed with $$.  Symbols are prefixed with [3 followed by a symbol name or their ordinal value. <Test if a string is a valid JS identifier without escaping. \Attempts to find a human-readable name for a symbol, if none has been specified returns the  ordinal value. =Checks whether an identifier name is reserved in Javascript. JFinds the value stored for a data constructor in the current environment. N This is a partial function, but if an invalid type has reached this far then + something has gone wrong in typechecking. NChecks whether a data constructor is the only constructor for that type, used 9 to simplify the check when generating code for binders. 4Checks whether a data constructor is for a newtype. ;Checks the number of arguments a data constructor accepts. AChecks whether a data constructor has no arguments, for example, \.    None]DInline type class dictionaries for >>= and return for the Eff monad E.g. Prelude[>>=](dict)(m1)(function(x) {  return ...;  }) becomes function __do {  var x = m1();  ...  } ^"Inline functions in the ST module ]^]^None__NoneAApply a series of optimizer passes to simplified Javascript code ``None a%The state object used in this module bEA map from names bound (in the input) to their names (in the output) cEThe set of names which have been used and are in scope in the output dDRuns renaming starting with a list of idents for the initial scope. eMCreates a new renaming scope using the current as a basis. Used to backtrack  when leaving an Abs. fLAdds a new scope entry for an ident. If the ident is already present, a new & unique name is generated and stored. g(Finds the new name to use for an ident. h)Finds idents introduced by declarations. -Renames within each declaration in a module. iJRenames within a declaration. isTopLevel is used to determine whether the L declaration is a module member or appearing within a Let. At the top level N declarations are not renamed or added to the scope (they should already have N been added), whereas in a Let declarations are renamed if their name shadows  another in the current scope. jRenames within a value. k"Renames within case alternatives. lRenames within binders. manbcodefghijkl manbcodefghijklNone aGenerate code in the simplified Javascript intermediate representation for all declarations in a  module. YGenerate code in the simplified Javascript intermediate representation for a declaration p Generate keyBvalue pairs for an object literal exporting values from a module. qaGenerate code in the simplified Javascript intermediate representation for a variable based on a  PureScript identifier. r`Generate code in the simplified Javascript intermediate representation for an accessor based on b a PureScript identifier. If the name is not valid in Javascript (symbol based, reserved name) an  indexer is returned. sbGenerate code in the simplified Javascript intermediate representation for a value or expression. tShallow copy an object. u\Generate code in the simplified Javascript intermediate representation for a reference to a  variable. v\Generate code in the simplified Javascript intermediate representation for a reference to a * variable that may have a qualified name. waGenerate code in the simplified Javascript intermediate representation for pattern match binders  and guards. x[Generate code in the simplified Javascript intermediate representation for a pattern match  binder. yzpqr{stuvwx=  !"#$%&'()*+,-./0123456789:;<=>?@Ayzpqr{stuvwxNone|FGenerate a pretty-printed string representing a Javascript expression sGenerate a pretty-printed string representing a collection of Javascript expressions at the same indentation level }QGenerate an indented, pretty-printed string representing a Javascript expression ~|}~|}None4Generate a pretty-printed string representing a Row ]Generate a pretty-printed string representing a Type, as it should appear inside parentheses 5Generate a pretty-printed string representing a Type  None<Generate a pretty-printed string representing an expression 7Generate a pretty-printed string representing a Binder 3None None A stack trace for an error Compilation errors Error message #The value where the error occurred %Optional source position information )Type for sources of type checking errors $An error which originated at a Type $An error which originated at a Expr KRethrow an error with a more detailed error message in the case of failure 2Rethrow an error with source position information  !NoneERemove explicit parentheses and reorder binary operator applications "None Replace all DoNotationBind and DoNotationValue? constructors with applications of the Prelude.(>>=) function,  and all  DoNotationLet$ constructors with let expressions. #NoneJReplace all top level type declarations in a module with type annotations >Replace all top level type declarations with type annotations $NoneTReplace all sets of mutually-recursive declarations in a module with binding groups CCollapse all binding groups in a module to individual declarations HReplace all sets of mutually-recursive declarations with binding groups 7Collapse all binding groups to individual declarations pConvert a group of mutually-recursive dependencies into a BindingGroupDeclaration (or simple ValueDeclaration). %NoneNAn imported environment for a particular module. This also contains the module's own members. ILocal names for types within a module mapped to to their qualified names ULocal names for data constructors within a module mapped to to their qualified names KLocal names for classes within a module mapped to to their qualified names JLocal names for values within a module mapped to to their qualified names )The exported declarations from a module. $The types exported from each module &The classes exported from each module %The values exported from each module NThe global export environment - every declaration exported from every module. _Updates the exports for a module from the global environment. If the module was not previously 3 present in the global environment, it is created. .Adds an empty module to an ExportEnvironment. =Adds a type belonging to a module to the export environment. (Adds a class to the export environment. (Adds a class to the export environment. [Adds an entry to a list of exports unless it is already present, in which case an error is  returned. GReplaces all local names with qualified names within a set of modules. aMake all exports for a module explicit. This may still effect modules that have an exports list, = as it will also make all data constructor exports explicit. [Replaces all local names with qualified names within a module and checks that all existing  qualified names are valid. 5Finds all exported declarations in a set of modules. `Filters the exports for a module to ensure only explicit exports are kept in the global exports  environment. ZFinds the imports within a module, mapping the imported module name to an optional set of # explicitly imported declarations. -Constructs a local environment for a module. UExtends the local environment for a module by resolving an import of another module. &NonehThe type checking monad, which provides the state of the type checker, and error reporting capabilities "State required for type checking:  The current  Environment )The next fresh unification variable name $The next type class dictionary name The current module 1Temporarily bind a collection of names to values 0Temporarily bind a collection of names to types CTemporarily make a collection of type class dictionaries available <Get the currently available list of type class dictionaries :Temporarily bind a collection of names to local variables ?Temporarily bind a collection of names to local type variables  .Update the visibility of all names to Defined  *Lookup the type of a value by name in the  Environment  0Lookup the visibility of a value by name in the  Environment  Assert that a name is visible  )Lookup the kind of a type by name in the  Environment Get the current  Environment  Update the  Environment  Modify the  Environment =Run a computation in the Check monad, starting with an empty  Environment mRun a computation in the Check monad, failing with an error, or succeeding with a return value and the final  Environment. 1Make an assertion, failing with an error message (Generate new type class dictionary name Lift a computation in the Check$ monad into the substitution monad. cRun a computation in the substitution monad, generating a return value and the final substitution. Typecheck in parallel                     'NoneAReplace all top-level binders in a module with case expressions. 5Replace all top-level binders with case expressions. (NoneeAdd type synonym declarations for type class dictionary types, and value declarations for type class " instance dictionary expressions.  )None-The desugaring pipeline proceeds as follows: 5 Introduce type synonyms for type class dictionaries ) Rebracket user-defined binary operators  Desugar do-notation using the  Prelude.Monad type class D Desugar top-level case declarations into explicit case expressions R Desugar type declarations into value declarations with explicit type annotations K Group mutually recursive value and data declarations into binding groups. ) Qualify any unqualified names and types *None:Generate foreign imports for all declarations in a module 4None>  !"#$%&'()*+,-./0123456789:;<=>?@A+None6Parse a type as it appears in e.g. a data constructor Parse a monotype Parse a polytype ,None!Read source position information  Parse a single declaration !7Parse a module header and a collection of declarations "Parse a collection of modules #Parse a value $Parse a binder %=Parse a binder as it would appear in a top level declaration &Parse a guard 7 !"     # $%& !"#$%& !"#&$%7 !"     # $%&5None> !"#$%&-None' Infer the kind of a single type (uInfer the kind of a type constructor with a collection of arguments and a collection of associated data constructors )OSimultaneously infer the kinds of several mutually recursive type constructors !_Solve the set of kind constraints associated with the data constructors for a type constructor "4Default all unknown kinds to the Star kind of types #Infer a kind for a type '($)!"#%&''()'() '($)!"#%&'.None(-Build a type substitution for a type synonym ):Replace all instances of a specific type synonym with the SaturatedTypeSynonym data constructor *#Replace all type synonyms with the SaturatedTypeSynonym data constructor ()***()*/None,*LA simplified representation of expressions which are used to represent type C class dictionaries at runtime, which can be compared for equality +A subclass dictionary ,1A dictionary which depends on other dictionaries -DA dictionary which is brought into scope by an instance declaration .?A dictionary which is brought into scope by a local constraint /3Unify two types, updating the current substitution 02Unify two rows, updating the current substitution _Common labels are first identified, and unified. Remaining labels and types are unified with a f trailing row unification variable, if appropriate, otherwise leftover labels result in a unification  error. +^Infer the types of multiple mutually-recursive values, and return elaborated values including / type class dictionaries and type annotations. 1,Check if a value contains a type annotation 2>Map a function over type annotations appearing inside a value 3QReplace type class dictionary placeholders with inferred type class dictionaries 4hCheck that the current set of type class dictionaries entail the specified type class goal, and, if so, + return a type class dictionary reference. 56Check all values in a list pairwise match a predicate 6Check that two types unify 7hCheck whether the type heads of two types are equal (for the purposes of type class dictionary lookup), Z and return a substitution from type variables to types which makes the type heads unify. 82Ensure skolem variables do not escape their scope 9,Ensure rows do not contain duplicate labels :*Ensure a row contains no duplicate labels ;"Setify"" all rows occuring inside a value <KReplace outermost unsolved unification variables with named type variables =ZRemove any ForAlls and ConstrainedType constructors in a type by introducing new unknowns  or TypeClassDictionary values. SThis is necessary during type checking to avoid unifying a polymorphic type with a  unification variable. >?Replace a single type variable with a new unification variable ?-Replace fully applied type synonyms with the SaturatedTypeSynonym( data constructor, which helps generate + better error messages during unification. @" Desaturate" SaturatedTypeSynonyms A?Replace a type synonym and its arguments with the aliased type BKEnsure a set of property names and value does not contain duplicate labels CVInfer a type for a value, rethrowing any error to provide a more useful error message DInfer a type for a value E?Infer the type of a property inside a record with a given type F<Infer the types of variables brought into scope by a binder GMCheck the types of the return values in a set of binders in a case statement HGenerate a new skolem constant IGenerate a new skolem scope JQSkolemize a type variable by replacing its instances with fresh skolem constants KKThis function has one purpose - to skolemize type variables appearing in a _ SuperClassDictionary placeholder. These type variables are somewhat unique since they are the ( only example of scoped type variables. L6Introduce skolem scope at every occurence of a ForAll MOCheck the type of a value, rethrowing errors to provide a better error message NCheck the type of a value O6Check the type of a collection of named record fields The laxu parameter controls whether or not every record member has to be provided. For object updates, this is not the case. P^Check the type of a function application, rethrowing errors to provide a better error message Q)Check the type of a function application R]Check whether one type subsumes another, rethrowing errors to provide a better error message S(Check whether one type subsumes another TTCompute the meet of two types, i.e. the most general type which both types subsume.  TODO: handle constrained types 8*+,-.UV/0+WXY123456789:;<=>?Z@A[\BCD]EFGHIJKLMN^OPQRST_`++4*.-,+UV/0+WXY123456789:;<=>?Z@A[\BCD]EFGHIJKLMN^OPQRST_`0Nonea(Type check all declarations in a module XAt this point, many declarations will have been desugared, but it is still necessary to * Kind-check all types and add them to the  Environment + Type-check all values and add them to the  Environment ' Bring type class instances into scope  Process module imports ,`Type check an entire module and ensure all types and classes defined within the module that are 1 required by exported members are also exported. bcdefghija,$     '()*+,, bcdefghija,1None -HA type class which collects the IO actions we need to be able to run in make mode .Get a file timestamp /Read a file as a string 0Write a text file 1Report an error 2Respond to a progress update 3 Compile a collection of modules .The compilation pipeline proceeds as follows: R Sort the modules based on module dependencies, checking for cyclic dependencies. % Perform a set of desugaring passes. [ Type check, and elaborate values to include type annotations and type class dictionaries. W Regroup values to take into account new value dependencies introduced by elaboration.  Eliminate dead code. 7 Generate Javascript, and perform optimization passes. ' Pretty-print the generated Javascript 5 Compiles in makeJ mode, compiling each module separately to a js files and an externs file RIf timestamps have not changed, the externs file can be used to provide the module's types without ' having to typecheck the module again. kTAdd an import declaration for a module if it does not already explicitly import it. -./01234l5mkno6  !"#$%&'()*+,-./0123456789:;<=>?@A      !"#/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456 34-./01256 -./01234l5mkno6p66789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                     ! " # $%&'()*+,-./0123456789:;<=>??@ABCDEFGHIJKLMNOPQRSSTUVWXYZ[\]^_`abcdefghijklmnoopqrstuvwxyz{|}~                    !!"##$$$$%&&&& & &!&"&#&$&%&&&'&(&)&*&+&,&-&.&/&0&1&2&3&4&5&6&7&8&9':';(<)=*>+?+@+A,B,C,D,E,F,G,H-I-J-K.L/M0N1O1P1Q1R1S1T1U1V1W1X2Y2Z2[2\2]2^2_2`2a2b2c2d2ef g h i j klm?nopqrstuvwxyz|{|{}~n  !!!!!!!!!!E!!!"$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%''''''((((((((((++++++++++++, , , , , ,,,,,,,,,,,,,,,,,,, ,!,",#,$,%,&,',(,),*,+,,,-,.,/,0,1,2,3,4,5,6,7,8-9-:-;-<-=->-?.@.A/B/C/D/E/F/G/H/I/J/K/L/M/N/O/P/Q/R/S/T/U/V/W/X/Y/Z/;/=/[/\/]/^/_/`/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v0w0x0y0z0{000|0}0~11111purescript-0.5.7.1 Language.PureScript.Parser.StateLanguage.PureScript.Traversals"Language.PureScript.CodeGen.JS.AST$Language.PureScript.Optimizer.Common$Language.PureScript.Optimizer.BlocksLanguage.PureScript.Constants$Language.PureScript.Optimizer.UnusedLanguage.PureScript.SupplyLanguage.PureScript.Options!Language.PureScript.Optimizer.TCOLanguage.PureScript.Names!Language.PureScript.Parser.Common!Language.PureScript.Pretty.CommonLanguage.PureScript.Kinds Language.PureScript.Parser.Kinds Language.PureScript.Pretty.KindsLanguage.PureScript.Types)Language.PureScript.TypeClassDictionariesLanguage.PureScript.Environment Language.PureScript.Declarations&Language.PureScript.ModuleDependencies'Language.PureScript.DeadCodeElimination"Language.PureScript.CodeGen.Common%Language.PureScript.Optimizer.MagicDo%Language.PureScript.Optimizer.InlinerLanguage.PureScript.OptimizerLanguage.PureScript.RenamerLanguage.PureScript.CodeGen.JSLanguage.PureScript.Pretty.JS Language.PureScript.Pretty.Types!Language.PureScript.Pretty.ValuesLanguage.PureScript.Errors#Language.PureScript.Sugar.Operators$Language.PureScript.Sugar.DoNotation*Language.PureScript.Sugar.TypeDeclarations'Language.PureScript.Sugar.BindingGroupsLanguage.PureScript.Sugar.Names%Language.PureScript.TypeChecker.Monad*Language.PureScript.Sugar.CaseDeclarations%Language.PureScript.Sugar.TypeClassesLanguage.PureScript.Sugar#Language.PureScript.CodeGen.Externs Language.PureScript.Parser.Types'Language.PureScript.Parser.Declarations%Language.PureScript.TypeChecker.Kinds(Language.PureScript.TypeChecker.Synonyms%Language.PureScript.TypeChecker.TypesLanguage.PureScript.TypeCheckerLanguage.PureScriptPaths_purescriptLanguage.PureScript.PrettyLanguage.PureScript.CodeGenLanguage.PureScript.Parser ParseStateindentationLevelfstMsndMthirdMmaybeMdefSJSJSRaw JSContinueJSBreakJSLabel JSInstanceOfJSTypeOfJSThrowJSReturnJSIfElseJSForInJSForJSWhile JSAssignmentJSVariableIntroductionJSBlock JSConditionalJSVarJSApp JSFunction JSAccessorJSObjectLiteral JSIndexerJSArrayLiteralJSBinaryJSUnaryJSBooleanLiteralJSStringLiteralJSNumericLiteralBinaryOperatorZeroFillShiftRight ShiftRight ShiftLeft BitwiseXor BitwiseOr BitwiseAndOrAndGreaterThanOrEqualTo GreaterThanLessThanOrEqualToLessThan NotEqualToEqualToModulusDivideMultiplySubtractAdd UnaryOperatorJSNewPositive BitwiseNotNotNegateeverywhereOnJSeverywhereOnJSTopDowneverythingOnJSapplyAll replaceIdent replaceIdents isReassigned isReboundisUsedtargetVariable isUpdatedremoveFromBlockcollapseNestedBlockscollapseNestedIfs$#<>++>>=+-*/%<><=>===/=&bar^&&|| unsafeIndexnegateshlshrzshr complementnotreturnpure' returnEscapeduntilEwhileErunST runSTArray stRefValuenewSTRef readSTRef writeSTRef modifySTRef peekSTArray pokeSTArraymkFnrunFn undefinedmonadEffDictionaryapplicativeEffDictionarybindEffDictionary numNumber ordNumbereqNumbereqString eqBoolean bitsNumberboolLikeBooleansemigroupStringsemigroupoidArrmain __superclass___unusedprimprelude preludeUnsafeeffst dataFunctionremoveCodeAfterReturnStatementsremoveUnusedArgremoveUndefinedAppSupplySupplyT unSupplyT runSupplyT evalSupplyT runSupply evalSupplyfresh freshNameOptionsoptionsNoPrelude optionsNoTcooptionsNoMagicDo optionsMainoptionsNoOptimizationsoptionsVerboseErrorsoptionsAdditional ModeOptions MakeOptionsCompileOptionsModeMakeCompilebrowserNamespaceentryPointModulescodeGenModulesdefaultCompileOptionsdefaultMakeOptionstco Qualified ModuleName ProperName runProperNameIdentOprunIdent runModuleNamemoduleNameFromStringqualifyreservedPsNamesopCharsreservedTypeNamesreservedOpNames identStart identLetteropStartopLetterlangDef tokenParserlexeme identifierreserved reservedOpoperator stringLiteral whiteSpacesemicolondotcommatickpipenatural properName moduleNameparseQualifiedintegerOrFloat parseIdentsquaresparensbracesanglessepBysepBy1semiSepsemiSep1commaSep commaSep1augmentfoldbuildPostfixParserparseIdentInfixmarkcheckIndentationindentedsamerunIndentParser PrinterStateindent blockIndent withIndent currentIndentprettyPrintManyprettyPrintObjectKeyKindFunKindRowBangStarKUnknowneverywhereOnKindseverythingOnKinds parseKindprettyPrintKindTypePrettyPrintForAllPrettyPrintObjectPrettyPrintArrayPrettyPrintFunction KindedTypeRConsREmptySkolemConstrainedTypeForAllSaturatedTypeSynonymTypeAppTypeConstructorTypeVarTUnknown SkolemScoperunSkolemScope rowToList rowFromList isMonoTypemkForAllreplaceTypeVarsreplaceAllTypeVarsusedTypeVariablesfreeTypeVariablesquantifymoveQuantifiersToFronteverywhereOnTypeseverywhereOnTypesTopDowneverywhereOnTypesMeverywhereOnTypesTopDownMeverythingOnTypesTypeClassDictionaryTypeTCDAlias TCDRegularTypeClassDictionaryInScopetcdName tcdClassNametcdInstanceTypestcdDependenciestcdType tcdExported DataDeclTypeNewtypeDataTypeKindLocalTypeVariable ExternData TypeSynonymDataTypeNameKindTypeInstanceDictionaryValueDataConstructor LocalVariableExternTypeClassAccessorImportValueNameVisibilityDefined UndefinedForeignImportTypeInlineJavascript ForeignImport EnvironmentnamestypesdataConstructors typeSynonymstypeClassDictionaries typeClassesinitEnvironmentprimNameprimTy tyFunctiontyStringtyNumber tyBooleantyArraytyObjectfunction primTypesBinderPositionedBinder NamedBinder ConsBinder ArrayBinder ObjectBinderConstructorBinder VarBinder NumberBinder StringBinder BooleanBinder NullBinderDoNotationElementPositionedDoNotationElement DoNotationLetDoNotationBindDoNotationValueCaseAlternativecaseAlternativeBinderscaseAlternativeGuardcaseAlternativeResultExprPositionedValueSuperClassDictionaryTypeClassDictionary!TypeClassDictionaryConstructorAppDoLet TypedValueCase Constructor IfThenElseVarAppAbs ObjectUpdateAccessor ObjectLiteral ArrayLiteralParensBinaryNoParens UnaryMinusBooleanLiteral StringLiteralNumericLiteralGuard DeclarationPositionedDeclarationTypeInstanceDeclarationTypeClassDeclarationImportDeclarationFixityDeclarationExternInstanceDeclarationExternDataDeclarationExternDeclarationBindingGroupDeclarationValueDeclarationTypeDeclarationTypeSynonymDeclarationDataBindingGroupDeclarationDataDeclarationImportDeclarationTypeHiding Qualifying UnqualifiedDeclarationRefPositionedDeclarationRefTypeInstanceRef TypeClassRefValueRefTypeRefModuleFixity SourcePos sourceName sourcePosLinesourcePosColumn AssociativityInfixInfixrInfixl Precedence isValueDecl isDataDecl isImportDeclisExternDataDeclisExternInstanceDecl isFixityDecl isExternDeclisTypeClassDeclarationcanonicalizeDictionary binderNameseverywhereOnValueseverywhereOnValuesTopDownMeverywhereOnValuesMeverythingOnValueseverythingWithContextOnValueseverywhereWithContextOnValuesM accumTypes ModuleGraph sortModuleseliminateDeadCode identToJsidentNeedsEscapingidentCharToStringnameIsJsReservedmoduleNameToJslookupConstructorisOnlyConstructorisNewtypeConstructorgetConstructorArityisNullaryConstructormagicDo etaConvertunThunk evaluateIifesinlineVariablesinlineOperatorinlineCommonOperatorsoptimizerenameInModules moduleToJsdeclToJs prettyPrintJSprettyPrintRowprettyPrintTypeAtomprettyPrintTypeprettyPrintValueprettyPrintBinder ErrorStackMultipleErrors runErrorStack CompileErrorcompileErrorMessagecompileErrorValuecompileErrorPosition ErrorSource TypeError ExprErrorprettyPrintErrorStackstringifyErrorStackisErrorNonEmpty showError mkErrorStack positionErrorrethrowrethrowWithPosition rebracketremoveSignedLiteralsdesugarDoModuledesugarTypeDeclarationsModuledesugarTypeDeclarationscreateBindingGroupsModulecollapseBindingGroupsModulecreateBindingGroupscollapseBindingGroupsdesugarImportsCheckunCheck CheckStatecheckEnv checkNextVarcheckNextDictNamecheckCurrentModule bindNames bindTypeswithTypeClassDictionariesgetTypeClassDictionariesbindLocalVariablesbindLocalTypeVariablesmakeBindingGroupVisiblelookupVariable getVisibilitycheckVisibilitylookupTypeVariablegetEnvputEnv modifyEnvrunCheck runCheck' guardWithfreshDictionaryName liftCheck liftUnifyparUdesugarCasesModule desugarCasesdesugarTypeClassesdesugar moduleToPs parseTypeAtom parseType parsePolyTypeparseDeclaration parseModule parseModules parseValue parseBinderparseBinderNoParens parseGuardkindOfkindsOf kindsOfAllsaturateAllTypeSynonymstypesOftypeCheckModule MonadMake getTimestamp readTextFile writeTextFile liftErrorprogresscompilecompile'makepreludeFilenamecatchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName$fMonadErroreSupplyTtco'$fShowQualified$fShowModuleName$fShowProperName $fShowIdent parseStar parseBang typeLiteralsmatchRowfunKind$fShowDataDeclType$fEqDeclarationRef$fShowSourcePos$fShowAssociativity usedModulestoModule getModuleNameKeydeclarationsByModule dependenciesbaseGHC.Base Data.MaybeNothingmagicDo'inlineST shouldInlineuntilFixedPoint RenameState rsBoundNames rsUsedNames runRenamenewScope updateScope lookupIdentfindDeclIdents renameInDecl renameInValuerenameInCaseAlternativerenameInBinderRename initState exportToJsvaraccessor valueToJs extendObjvarToJs qualifiedToJS bindersToJs binderToJs importToJsimportsaccessorStringprettyPrintJS1prettyPrintJS'literalsstring conditionalindexerlamapptypeOf instanceOfunarybinaryprettyStatementstypeAppappliedFunctionkindedinsertPlaceholders matchTypeAtom matchTypeforall_prettyPrintDeclarationprettyPrintCaseAlternativeprettyPrintDoNotationElement ifThenElse objectUpdateprettyPrintValue'prettyPrintBinderAtomprettyPrintBinder'matchConsBinderprettyPrintObjectPropertyBinderprettyPrintObjectProperty$fErrorErrorStack$fMonoidErrorStackChainrebracketModule removeParenscollectFixitiesensureNoDuplicatescustomOperatorTablematchOperatorstoAssoctokenparseOp parseTicksmatchOp desugarDotoBindingGroupcreateBindingGroupsForValuecollapseBindingGroupsForValue usedIdentsusedImmediateIdentsusedProperNamesgetIdent getProperNametoDataBindingGroup isTypeSynonym fromValueDeclImportEnvironment importedTypesimportedDataConstructorsimportedTypeClassesimportedValuesExports exportedTypesexportedTypeClassesexportedValuesExportEnvironmentupdateExportedModuleaddEmptyModuleaddType addTypeClassaddValue addExportelaborateExportsrenameInModule findExports filterExports findImportsresolveImports resolveImport desugarAbs inSameGrouptoDecls isVarBindertoTuplemakeCaseDeclarationDesugar MemberMap desugarModule desugarDeclmemberToNameAndTypetypeClassDictionaryDeclaration#typeClassMemberToDictionaryAccessormkSuperclassDictionaryNameunit!typeInstanceDictionaryDeclaration parseArray parseArrayOf parseFunction parseObjectparseTypeVariableparseTypeConstructor parseForAllparseConstrainedType parseAnyTypeparseNameAndTypeparseRowEndingparseRow sourcePos kindedIdentparseDataDeclarationparseTypeDeclarationparseTypeSynonymDeclarationparseValueDeclarationparseExternDeclarationparseAssociativity parseFixityparseFixityDeclarationparseImportDeclarationparseDeclarationRefparseTypeClassDeclarationparseTypeInstanceDeclaration positionedparseLocalDeclarationbooleanLiteralparseNumericLiteralparseStringLiteralparseBooleanLiteralparseArrayLiteralparseObjectLiteralparseIdentifierAndValueparseAbsparseVarparseConstructor parseCaseparseCaseAlternativeparseIfThenElseparseLetparseValueAtomparsePropertyUpdate parseAccessorparseDoparseDoNotationLetparseDoNotationBindparseDoNotationElementparseStringBinderparseBooleanBinderparseNumberBinderparseVarBinderparseNullaryConstructorBinderparseConstructorBinderparseObjectBinderparseArrayBinderparseNamedBinderparseNullBinderparseIdentifierAndBinder solveTypes starIfUnknowninfer freshKindVarinfer'$fUnifiableCheckKind $fPartialKindbuildTypeSubstitutionsaturateTypeSynonymDictionaryValueSubclassDictionaryValueDependentDictionaryValueGlobalDictionaryValueLocalDictionaryValue unifyTypes unifyRowsisTyped overTypesreplaceTypeClassDictionariesentailspairwise unifiesWithtypeHeadsAreEqualskolemEscapeCheckcheckDuplicateLabelssetify setifyAll varIfUnknowninstantiatePolyTypeWithUnknownsreplaceVarWithUnknownreplaceAllTypeSynonyms'desaturateAllTypeSynonymsexpandTypeSynonym'ensureNoDuplicateProperties inferProperty inferBinder checkBindersnewSkolemConstantnewSkolemScope skolemizeskolemizeTypesInValueintroduceSkolemScopecheckcheck'checkPropertiescheckFunctionApplicationcheckFunctionApplication'subsumes subsumes'meet UntypedDataTypeDatatypeDictionaryForBindingGroupcheckTypedBindingGroupElementtypeForBindingGroupElementreplaceAllTypeSynonymsexpandTypeSynonymexpandAllTypeSynonymsinferLetBindingcontainsTypeSynonyms$fUnifiableCheckType $fPartialType typeCheckAll addDataTypeaddDataConstructoraddTypeSynonymvalueIsNotDefinedaddTypeClassDictionariescheckDuplicateTypeArgumentscheckTypeClassInstanceaddDefaultImport generateMainreverseDependencies importPrim importPrelude