qOc      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !!!!!!!!!!!" # # # # ################### #!#"###$#%#&#'#(#)#*#+#,#-#.#/#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&v&w&x&y&z&{&|&}&~&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''(()))))))))))))*************+,,,,,,,,---./000000122222222222222222222222222222222222222222222 2 2 2 2 2333444444444444444 4!4"4#4$4%4&4'4(4)4*4+4,4-4.4/404142434445464748494:4;4<4=4>4?4@4A4B4C4D4E4F4G4H4I4J4K4L4M4N4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4\4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}4~44444444444444444444444444444444444444444444444444444444444444444444444444444444455677777777777777777777777778889999999:;;;;;;;;;;<<======= = = = = =================== =!="=#=$=%=&='=(=)>*>+>,>-?.@/@0@1@2A3A4B5B6B7C8D9E:F;G<H=H>H?I@JAKBKCLDLEMFNGOHOIOJOKOLOMPNPOPPPQPRPSPTPUPVQWRXSYTZU[U\U]U^U_U`UaUbUcUdUeUfUgUhUiUjUkUlUmUnVoWpWqWrWsWtWuWvWwWxWyWzW{W|W}W~WWWWWWWWWWWWWWWWWXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY Y Y Y Y YYYYYYYYYYYZZZZZZZZ Z!Z"Z#[$[%\&]'](^)_*_+_,_-`.`/`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`PaQaRaSaTaUaVaWaXaYaZa[a\a]a^a_a`aaabaiSafe(     None( GGlob relative to the current directory, and produce relative pathnames. )Glob pattern for PureScript source files. -Glob pattern for PureScript dependency files.    Safe(Safe(State for the parser monad*The most recently marked indentation levelSafe(Safe(357>L;A replacement for WriterT IO which uses mutable references.5Run a Logger computation, starting with an empty log.   Safe(-UData type for literal values. Parameterised so it can be used for Exprs and Binders. A numeric literal!A string literal"A character literal#A boolean literal$An array literal%An object literal !"#$% !"#$% !"#$% !"#$%Safe(t&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~t&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~t&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~t&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe( None(N Source nameStart of the spanSource position information Line number Column number  bSafe( cdefghijklmnodjklmno cdefghijklmno None(4FGNp>A module is just a list of elements of the types listed above.q<There are four types of module element we are interested in:R1) Require statements 2) Member declarations 3) Export lists 4) Everything else|Each is labelled with the original AST node which generated it, so that we can dump it back into the output during codegen.rAn export is either a "regular export", which exports a name from the regular module we are in, or a reexport of a declaration in the corresponding foreign module.WRegular exports are labelled, since they might re-export an operator with another name.syA piece of code is identified by its module and its name. These keys are used to label vertices in the dependency graph.7A module is identified by its module name and its type.VModules are either "regular modules" (i.e. those generated by psc) or foreign modules.The type of error messages. We separate generation and rendering of errors using a data type, in case we need to match on error types later.3Prepare an error message for consumption by humans.tFUnpack the node inside a JSNode. This is useful when pattern matching.uFCalculate the ModuleIdentifier which a require(...) statement imports.vOCompute the dependencies of all elements in a module, and add them to the tree.YMembers and exports can have dependencies. A dependency is of one of the following forms: 1) module.name or member["name"]where module was imported usingvar module = require( Module.Name);2) nameAwhere name is the name of a member defined in the current module.w1Attempt to create a Module from a Javascript AST.xEach type of module element is matched using pattern guards, and everything else is bundled into the Other constructor.x=Eliminate unused code based on the specified entry point set.yzTopologically sort the module dependency graph, so that when we generate code, modules can be defined in the right order.zA module is empty if it contains no exported members (in other words, if the only things left after dead code elimination are module imports and "other" foreign code).<If a module is empty, we don't want to generate code for it.{?Generate code for a set of modules, including a call to main().8Modules get defined on the global PS object, as follows:>var PS = { }; (function(exports) { ... })(PS[ Module.Name] = PS[ Module.Name ] || {});LIn particular, a module and its foreign imports share the same namespace inside PS. This saves us from having to generate unique names for a module and its foreign imports, and is safe since a module shares a namespace with its foreign imports in PureScript as well (so there is no way to have overlaps in code generated by psc).The bundling function. This function performs dead code elimination, filters empty modules and generates and prints the final Javascript bundle."p|q}~rstuvwxyz{ main module namespace input modulesCThe input modules. Each module should be javascript rendered from Vc or psc.WEntry points. These module identifiers are used as the roots for dead-code eliminationAn optional main module.The namespace (e.g. PS).The require path prefixp|q}~rstuvwxyz{ None(C None(7Safe( !The data type of compiler optionsDisable tail-call elimination>Disable inlining of calls to return and bind for the Eff monad#When specified, checks the type of mainN in the module, and generate a call to run main after the module definitions.Skip all optimizationsVerbose error message)Remove the comments from the generated js)The path to prepend to require statementsDefault make options None(-=>:A qualified name, i.e. a name with an optional module name Module names$The closed set of proper name types.TProper names, i.e. capitalized names for e.g. module names, type//data constructors.Names for value identifiersAn alphanumeric identifier%A symbolic name for an infix operator"A generated name for an identifierCoerces a ProperName from one ProperNameType to another. This should be used with care, and is primarily used to convert ClassNames into TypeNames after classes have been desugared.7Provide a default module name, if a name is unqualified4Makes a qualified value from a name and module name.,Remove the module name from a qualified nameNChecks whether a qualified value is actually qualified with a module referenceRChecks whether a qualified value is not actually qualified with a module referenceFChecks whether a qualified value is qualified with a particular module#&None(-Data type for bindersWildcard binder&A binder which matches a literal value"A binder which binds an identifier)A binder which matches a data constructor/A binder which binds its input to an identifierNone(-"An alternative in a case statement6A collection of binders with which to match the inputs9The result expression or a collect of guarded expressionsSA guard is just a boolean-valued expression that appears alongside a set of bindersA let or module binding.(Non-recursive binding for a single value3Mutually recursive binding group for several values#Data type for expressions and terms A literal value =A data constructor (type name, constructor name, field names) A record property accessor Partial record update Function introductionFunction applicationVariableA case expression A let binding"Extract the annotation from a termModify the annotation on a term                     None(None(Data constructor metadata6The constructor is for a type with a single construcor7The constructor is for a type with multiple construcorsMetadata annotations)The contained value is a data constructor The contained value is a newtype9The contained value is a typeclass dictionary constructor/The contained reference is for a foreign memberNone(The data type of kinds !Unification variable of type Kind!The kind of types"The kind of effects#5Kinds for labelled, unordered rows without duplicates$Function kinds  !"#$%&'(  !"#$%&'  !"#$((%&' !"#$%&'(None(C)A typeclass constraint*The type of types+#A unification variable of type Type,A named type variable-:A type wildcard, as would appear in a partial type synonym.A type constructor/A type application0Forall quantifier1+A type with a set of type class constraints2A skolem constant3 An empty row4A non-empty row5A type with a kind annotation6%A placeholder used in pretty printing7%A placeholder used in pretty printing8%A placeholder used in pretty printing90An identifier for the scope of a skolem variable<4Convert 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 shadowingA'Replace named type variables with typesB.Collect all type variables appearing in a typeC3Collect all free type variables appearing in a typeDEUniversally quantify over all type variables appearing free in a typeE5Move all universal quantifiers to the front of a typeF"Check if a type contains wildcards%)*+,-./0123456789:;<=>?@ABCDEFGHIJKLM$)*+,-./0123456789:;<=>?@ABCDEFGHIJKL&9:;*+,-./012345678)MM<=>?@ABCDEFGHIJKL)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNone( NA simplified representation of expressions which are used to represent type class dictionaries at runtime, which can be compared for equalityO>A dictionary which is brought into scope by a local constraintPCA dictionary which is brought into scope by an instance declarationQ0A dictionary which depends on other dictionariesRA subclass dictionaryS;Data representing a type class dictionary which is in scopeUCThe identifier with which the dictionary can be accessed at runtimeV8How to obtain this instance via superclass relationshipsWDThe name of the type class to which this type class instance appliesX3The types to which this type class instance appliesYLType class dependencies which must be satisfied to construct this dictionary NOPQRSTUVWXY NOPQRSTUVWXY STUVWXYNOPQRNOPQRSTUVWXYNone(Z[\]Z[\Z[\]]Z[\]None(^Data type for binders_Wildcard binder`(A binder which matches a boolean literala'A binder which matches a string literalb*A binder which matches a character literalc(A binder which matches a numeric literald"A binder which binds an identifiere)A binder which matches a data constructorf8A binder which matches a record and binds its propertiesg6A binder which matches an array and binds its elementsh/A binder which binds its input to an identifieri)A binder with source position informationjA binder with a type annotationk8Collect all names introduced in binders in an expression^_`abcdefghijk^_`abcdefghijk^_`abcdefghijk^ _`abcdefghijkNone(8l/Data type for simplified Javascript expressionsmA numeric literalnA string literaloA boolean literalpA unary operator applicationqA binary operator applicationrAn array literalsAn array indexer expressiontAn object literalu&An object property accessor expressionv8A function introduction (optional name, arguments, body)wFunction applicationxVariableyConditional expressionz A block of expressions in braces{3A variable introduction and optional initialization|A variable assignment} While loop~For loop ForIn loopIf-then-else statementReturn statementThrow statementType-Of operatorInstanceOf testLabelled statementBreak statementContinue statementVRaw Javascript (generated when parsing fails for an inline foreign import declaration)Commented JavascriptBuilt-in binary operatorsNumeric additionNumeric subtractionNumeric multiplicationNumeric division RemainderGeneric equality testGeneric inequality testNumeric less-thanNumeric less-than-or-equalNumeric greater-thanNumeric greater-than-or-equal Boolean and Boolean or Bitwise and Bitwise or Bitwise xorBitwise left shiftBitwise right shift"Bitwise right shift with zero-fillBuilt-in unary operatorsNumeric negationBoolean negationBitwise negationNumeric unary 'plus' Constructor<lmnopqrstuvwxyz{|}~<lmnopqrstuvwxyz{|}~<lmnopqrstuvwxyz{|}~lmnopqrstuvwxyz{|}~None(Eliminate tail callsNone(@Collapse blocks which appear nested directly below another blockNone( Type alias for basic annotations#Initial annotation with no metadata&Remove the comments from an annotationNone(   None(FCWe use Text.Parsec.Token to implement the string and number lexemes/A token parser based on the language definition1Parse zero or more values separated by semicolons0Parse one or more values separated by semicolons-Parse zero or more values separated by commas,Parse one or more values separated by commas)A list of purescript reserved identifiers+The characters allowed for use in operators^88>None(4 Parse a module name0Parse a qualified name, i.e. M.name or just name-Parse an identifier or parenthesized operatornRun the first parser, then match the second if possible, applying the specified function on a successful matchnRun the first parser, then match the second zero or more times, applying the specified function for each matchPBuild a parser from a smaller parser and a list of parsers for postfix operators"Mark the current indentation level;Check that the current identation level matches a predicateACheck that the current indentation level is past the current markWCheck that the current indentation level is at the same indentation as the current mark?Read the comments from the the next token, without consuming it Run a parser     None( Parse a kind!None(Wrap a string in parentheses)Number of characters per identation level)Pretty print with a new indentation level!Get the current indentation levelPrint many lines.Prints an object key, escaping reserved names.RPlace a box before another, vertically when the first box takes up multiple lines.    "Safe(3Exit with an error message and a crash report link.#None(*  The type ('data' or  'newtype') of a data type declaration A standard data constructor A newtype constructor The kinds of a type  Data type Type synonym Foreign dataA local type variableA scoped type variableA flag for whether a name is for an private or public value - only public values will be included in a generated externs file.mA private value introduced as an artifact of code generation (class instances, class member accessors, etc.)@A public value for a module member or foreing import declaration.A name for member introduced by foreign import!The visibility of a name in scopeDThe name is defined in the current binding group, but is not visible_The name is defined in the another binding group, or has been made visible by a function binderThe  Environment; defines all values and types which are currently in scope:Value names currently in scopeType names currently in scopeyData constructors currently in scope, along with their associated type constructor name, argument types and return type. Type synonyms currently in scope!Available type class dictionaries  Type classes!TThe initial environment with no values and only the default javascript types defined#)Construct a ProperName in the Prim module$#Construct a type in the Prim module%Type constructor for functions&Type constructor for strings'Type constructor for strings(Type constructor for numbers)Type constructor for integers*Type constructor for booleans+Type constructor for arrays,Type constructor for objects-!Check whether a type is an object."Check whether a type is a function0$Smart constructor for function types1pThe primitive types in the external javascript environment with their associated kinds. There is also a pseudo Partial8 type that corresponds to the class with the same name.2/The primitive class map. This just contains to PartialB class, used as a kind of magic constraint for partial functions.3GFinds information about data constructors from the current environment.43Checks whether a data constructor is for a newtype.5<Finds information about values from the current environment.0      !"#$%&'()*+,-./012345678-      !"#$%&'()*+,-./0123451 !     "76#$%&'()*+,-./01234588      !"#$%&'()*+,-./012345678$None(95Parse a type as it appears in e.g. a data constructor:Parse a monotype;Parse a polytype<&Parse an atomic type with no wildcards9:;<9:;<:;<99:;<%None(=Fixity data for infix operators?!Associativity for infix operatorsC(A precedence level for an infix operator =>?@ABCDEFGH =>?@ABCDE C?@ABDEHG=>F=>?@ABCDEFGH&None(NURI"A statement in a do-notation blockJ A monadic value without a binderKA monadic value with a binderL0A let statement, i.e. a pure value with a binderM6A do notation element with source position informationN"An alternative in a case statementP6A collection of binders with which to match the inputsQ9The result expression or a collect of guarded expressionsR#Data type for expressions and termsSA numeric literalTA string literalUA character literalVA boolean literalWA prefix -, will be desugaredXqBinary operator application. During the rebracketing phase of desugaring, this data constructor will be removed.YjExplicit parentheses. During the rebracketing phase of desugaring, this data constructor will be removed.ZOperator section. This will be removed during desugaring and replaced with a partially applied operator or lambda to flip the arguments.[An array literal\An object literal]An object constructor (object literal with underscores). This will be removed during desugaring and expanded into a lambda that returns an object literal.^ An object property getter (e.g. `_.x`k). This will be removed during desugaring and expanded into a lambda that reads a property from an object._&An record property accessor expression`Partial record updateayPartial record updater. This will be removed during desugaring and expanded into a lambda that returns an object update.bFunction introductioncFunction applicationdVariablee%Conditional (if-then-else expression)fA data constructorgA case expression. During the case expansion phase of desugaring, top-level binders will get desugared into case expressions, hence the need for guards and multiple binders per branch here.hA value with a type annotationi A let bindingjA do-notation blockk\An application of a typeclass dictionary constructor. The value should be an ObjectLiteral.lA placeholder for a type class dictionary to be inserted later. At the end of type checking, these placeholders will be replaced with actual expressions representing type classes dictionaries which can be evaluated at runtime. The constructor arguments represent (in order): whether or not to look at superclass implementations when searching for a dictionary, the type class name and instance type, and the type class dictionaries in scope.m`A typeclass dictionary accessor, the implementation is left unspecified until CoreFn desugaring.neA placeholder for a superclass dictionary to be turned into a TypeClassDictionary during typecheckingo(A value with source position informationpSA guard is just a boolean-valued expression that appears alongside a set of bindersq0The members of a type class instance declarationrThis is a derived instances%This is a regular (explicit) instancetThe data type of declarationsuMA data type declaration (data or newtype, name, arguments, data constructors)v:A minimal mutually recursive set of data type declarationsw2A type synonym declaration (name, arguments, type)x)A type declaration for a value (name, ty)yDA value declaration (name, top-level binders, optional guard, value)z6A minimal mutually recursive set of value declarations{)A foreign import declaration (name, type)|'A data type foreign import (name, kind)}UA fixity declaration (fixity data, operator name, value the operator is an alias for)~'A module import (module name, qualified unqualifiedWhiding, optional "qualified as" name) TODO: also a boolean specifying whether the old  qualifiedK syntax was used, so a warning can be raised in desugaring (remove for 0.9)GA type class declaration (name, argument, implies, member declarations)bA type instance declaration (name, dependencies, class name, instance types, member declarations).A declaration with source position information8The data type which specifies type of import declaration,An import with no explicit list: `import M`.IAn import with an explicit list of references to import: `import M (foo)`DAn import with a list of references to hide: `import M hiding (foo)`0An item in a list of explicit imports or exports)A type constructor with data constructorsA value A type class]A type class instance, created during typeclass desugaring (name, class name, instance types)A module, in its entiretylAn unspecified ProperName ref. This will be replaced with a TypeClassRef or TypeRef during name desugaring.8A declaration reference with source position informationA module declaration, consisting of comments about the module, a module name, a list of declarations, and a list of the declarations that are explicitly exported. If the export list is Nothing, everything is exported.Return a module's name.SAdd an import declaration for a module if it does not already explicitly import it.Finds duplicate values in a list of declaration refs. The returned values are the duplicate refs with data constructors elided, and then a separate list of duplicate data constructors. A traversal for TypeInstanceBody,Test if a declaration is a value declaration@Test if a declaration is a data type or type synonym declaration(Test if a declaration is a module import3Test if a declaration is a data type 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 instance declaration1Test if a declaration is a type class declarationCRecursively flatten data binding groups in the list of declarations[IJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~XIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~]tuvwxyz{|}~qrspRSTUVWXYZ[\]^_`abcdefghijklmnoNOPQIJKLMIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrst uvwxyz{|}~'None((None(Return a list of all declarations which are exported from a module. This function descends into data declarations to filter out unexported data constructors, and also filters out type instance declarations if they refer to classes or types which are not themselves exported.]Note that this function assumes that the module has already had its imports desugared using Ld. It will produce incorrect results if this is not the case - for example, type class instances will be incorrectly removed in some cases.Filter out all data constructors from a declaration which are not exported. If the supplied declaration is not a data declaration, this function returns it unchanged.Filter out all the type instances from a list of declarations which reference a type or type class which is both local and not exported.Note that this function assumes that the module has already had its imports desugared using "Language.PureScript.Sugar.Names.desugarImports". It will produce incorrect results if this is not the case - for example, type class instances will be incorrectly removed in some cases.LGet all type and type class names referenced by a type instance declaration.Test if a declaration is exported, given a module's export list. Note that this function does not account for type instance declarations of non-exported types, or non-exported data constructors. Therefore, you should prefer " to this function, where possible._Test if a data constructor for a given type is exported, given a module's export list. Prefer " to this function, where possible.)None(4Convert an Ident into a valid Javascript identifier:,Alphanumeric characters are kept unmodified.2Reserved javascript identifiers are prefixed with $$.Symbols are prefixed with 2 followed by a symbol name or their ordinal value.;Test if a string is a valid JS identifier without escaping.kAttempts 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.=Checks whether a name matches a built-in value in Javascript.    *None(    +None(CInline type class dictionaries for >>= and return for the Eff monadE.g.;Prelude[">>="](dict)(m1)(function(x) { return ...; })becomes-function __do { var x = m1(); ... }!Inline functions in the ST module,None(---None(.None(4@Apply a series of optimizer passes to simplified Javascript code/None(4Generate a pretty-printed string representing a Kind0None(3Generate a pretty-printed string representing a Row\Generate a pretty-printed string representing a Type, as it should appear inside parentheses4Generate a pretty-printed string representing a Type1None(EGenerate a pretty-printed string representing a Javascript expressionrGenerate a pretty-printed string representing a collection of Javascript expressions at the same indentation levelPGenerate an indented, pretty-printed string representing a Javascript expressioneNone(^_`abcdefghijk=>?@ABCDEIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~2None(G8A type or value declaration appearing in an externs fileA type declarationA type synonymA data construtorA value declarationA type class declarationAn instance declaration'A fixity declaration in an externs file!The associativity of the operator$The precedence level of the operatorThe operator symbol&The value the operator is an alias for"A module import in an externs fileThe imported module-The import type: regular, qualified or hiding+The imported-as name, for qualified imports4The data which will be serialized to an externs fileThe externs version Module nameList of module exports List of module imports $List of operators and their fixities "List of type and value declaration *Convert an externs file back into a module 9Generate an externs file for all declarations in a module5     1     1          3None( 5Render an aligned list of items separated with commasPretty-print an expression CPretty-print an atomic expression, adding parentheses if necessary.6Generate a pretty-printed string representing a Binder            fNone( 4None(47CHow critical the issue isLA map from rigid type variable name/unknown variable pairs to new variables.A stack trace for an error!Categories of hints'GError message hints, providing more detailed information about failure.<A type of error messages Get the source span for an error Get the module name for an error3Remove the module name and span hints from an error.Get the error code for a particular error type5Check whether a collection of errors is empty or not.6Create an error set from a single simple error message/Create an error set from a single error message?Lift a function on ErrorMessage to a function on MultipleErrorsAdd a hint to an error message1Extract nested error messages from wrapper errors5Pretty print a single error, simplifying if necessaryPretty print multiple errorsPretty print multiple warningsPretty print warnings as a BoxPretty print errors as a Box)Pretty print a Parsec ParseError as a Box(Pretty print ParseError detail messages. Adapted from gh, see  Hhttps://github.com/aslatter/parsec/blob/v3.1.9/Text/Parsec/Error.hs#L173./Indent to the right, and pad on top and bottom.JRethrow an error with a more detailed error message in the case of failure1Rethrow an error with source position informationCollect errors in in parallel !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ξ<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~'()*+,-./0123456789:;!"#$%& 0 !"#$%&'()*+,-./0123456789:;?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~5None(44A list of modules with their transitive dependencies:Sort a collection of modules based on module dependencies.6Reports an error if the module graph contains a cycle.NCalculate a list of used modules based on explicit imports and qualified namesFConvert a strongly connected component of the module graph to a module6None(4N 8There are two modes of failure for the redundancy check: WExhaustivity was incomplete due to too many cases, so we couldn't determine redundancy.OWe didn't attempt to determine redundancy for a binder, e.g. an integer binder.+We want to warn the user in the first case.RQualifies a propername from a given qualified propername and a default module nameGiven an environment and a datatype or newtype name, this function returns the associated data constructors if it is the case of a datatype where: - ProperName is the name of the constructor (for example, NothingN in Maybe) - [Type] is the list of arguments, if it has (for example, Just has [TypeVar "a"])Replicates a wildcard binderBApplies a function over two lists of tuples that may lack elementsFind the uncovered set between two binders: the first binder is the case we are trying to cover, the second one is the matching binderReturns the uncovered set of binders the first argument is the list of uncovered binders at step i the second argument is the (i+1)th clause of a pattern matching definitionZThe idea of the algorithm is as follows: it processes each binder of the two lists (say, x and yU) one by one at each step two cases arises: - there are no missing cases between x and y: this is very straightforward, it continues with the remaining cases but keeps the uncovered binder in its position. - there are missing cases, let us call it the set U5: on the one hand, we mix each new uncovered case in U with the current tail of uncovered set. On the other hand, it continues with the remaining cases: here we can use x. (but it will generate overlapping cases), or y,, which will generate non-overlapping cases.As an example, consider:wdata N = Z | S N f Z Z = Z --> {[S _, _], [Z, S _]} which are the right non-overlapping cases (GHC uses this). if we use x instead of y (in this case, y stands for Z and x for `_`i) we obtain: f Z Z = Z --> {[S _, _], [_, S _]} you can see that both cases overlaps each other. Up to now, we've decided to use x~ just because we expect to generate uncovered cases which might be redundant or not, but uncovered at least. If we use y instead, we'll need to have a redundancy checker (which ought to be available soon), or increase the complexity of the algorithm.Guard handling+We say a guard is exhaustive iff it has an  (or truep) expression. Example: f x | x < 0 = 0 | otherwise = 1 is exhaustive, whereas `f x | x < 0` is not5The function below say whether or not a guard has an # expression It is considered that  is defined in Prelude.Returns the uncovered set of case alternativeseMain exhaustivity checking function Starting with the set `uncovered = { _ }` (nothing covered, one `_` for each function argument), it partitions that set with the new uncovered cases, until it consumes the whole set of clauses. Then, returns the uncovered set of case alternatives.1Exhaustivity checking over a list of declarations*Exhaustivity checking over a single module   7None(4N9The imports and exports for a collection of modules. The  is used to store the source location of the module with a given name, used to provide useful information when there is a duplicate module definition.(The exported declarations from a module.UThe types exported from each module along with the module they originally came from.WThe classes exported from each module along with the module they originally came from.VThe values exported from each module along with the module they originally came from.KThe imported declarations for a module, including the module's own members.HLocal names for types within a module mapped to to their qualified namesTLocal names for data constructors within a module mapped to to their qualified namesJLocal names for classes within a module mapped to to their qualified namesILocal names for values within a module mapped to to their qualified names;The modules that have been imported into the current scope.RThe names of "virtual" modules that come into existence when "import as" is used. An empty  value. An empty  value. Extracts the  from an  value. Extracts the  from an  value. Extracts the  from an  value.!The exported types from the Prim module0Environment which only contains the Prim module.gSafely adds a type and its data constructors to some exports, returning an error if a conflict occurs.MSafely adds a class to some exports, returning an error if a conflict occurs.MSafely adds a value to some exports, returning an error if a conflict occurs."eAdds an entry to a list of exports unless it is already present, in which case an error is returned.#IRaises an error for when there is more than one definition for something.SWhen reading a value from the imports, check that there are no conflicts in scope.!"#!"#8None(4FNU|Finds the imports within a module, mapping the imported module name to an optional set of explicitly imported declarations.)Constructs a set of imports for a module.7Constructs a set of imports for a single module import.$TExtends the local environment for a module by resolving an import of another module.%$%$9None(4NSMap of module name to list of imported names from that module which have been used..Imported name used in some type or expression.Find and warn on:3Unused import statements (qualified or unqualified),Unused references in an explicit import listImplicit imports of modulesoImplicit imports into a virtual module (unless the virtual module only has members from one module imported)Imports using hiding- (this is another form of implicit importing)&'()*+,-./0&'()*+,-./0:None(4GNTLint the PureScript AST. | | Right now, this pass only performs a shadowing check. ;None(4FN 1 Read source position informationParse a single declaration6Parse a module header and a collection of declarations)Parse a collection of modules in parallelParse a collection of modules2/Parse an expression in backticks or an operator31Expressions including indexers and record updates Parse a valueParse a binder<Parse a binder as it would appear in a top level declaration Parse a guardE1456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV2WXYZ[\]^3_`abcdefghijk  E1456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV2WXYZ[\]^3_`abcdefghijk<None(4lliNone(Y9:;<=None !"(3457CIN%Unification variables State required for type checking The current  Environment"The next type unification variable"The next kind unification variableThe next skolem variable The next skolem scope constant The current module The current substitution :A substitution of unification variables for types or kindsType substitutionKind substitutionAn empty substitutionCreate an empty  CheckState0Temporarily bind a collection of names to values/Temporarily bind a collection of names to types/Temporarily bind a collection of names to typesBTemporarily make a collection of type class dictionaries available:Get the currently available map of type class dictionaries+Lookup type class dictionaries in a module.9Temporarily 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 DefinedQUpdate the visibility of all names to Defined in the scope of the provided action6Perform an action while preserving the names from the  Environment.*Lookup the type of a value by name in the  Environment0Lookup the visibility of a value by name in the  EnvironmentAssert 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$DRun a computation in the typechecking monad, starting with an empty  Environment%tRun a computation in the typechecking monad, failing with an error, or succeeding with a return value and the final  Environment.&0Make an assertion, failing with an error message'bRun a computation in the substitution monad, generating a return value and the final substitution.(|Run a computation in the substitution monad, generating a return value, the final substitution and updating warnings values.'      !"#$%&'('      !"#$%&'('      !"#$%&'(      !"#$%&'(>None (3457FIN mGenerate a fresh kind variablen2Update the substitution to solve a kind constraintoApply a substitution to a kindp2Make sure that an unknown does not occur in a kindqUnify two kinds)Infer the kind of a single type*QInfer the kind of a single type, returning the kinds of any scoped type variables+tInfer the kind of a type constructor with a collection of arguments and a collection of associated data constructors,NSimultaneously infer the kinds of several mutually recursive type constructorsr^Solve the set of kind constraints associated with the data constructors for a type constructors3Default all unknown kinds to the Star kind of typestInfer a kind for a typemnopq)*+u,rstv)*+,)*+,mnopq)*+u,rstv?None!"(47Gw$Replace fully applied type synonyms.w---w-@None(4NU.SReplace all sets of mutually-recursive declarations in a module with binding groups/BCollapse all binding groups in a module to individual declarations16Collapse all binding groups to individual declarationsxoConvert a group of mutually-recursive dependencies into a BindingGroupDeclaration (or simple ValueDeclaration)../01yz{|}~x./010.1/./01yz{|}~xANone(4N2@Replace all top-level binders in a module with case expressions.2Validates that case head and binder lengths match.34Replace all top-level binders with case expressions. 232332 23BNone(4N4Add type synonym declarations for type class dictionary types, and value declarations for type class instance dictionary expressions. 456456456 456CNone(74Desugars a module from AST to CoreFn representation.Find module names from qualified references to values. This is used to ensure instances are imported from any module that is referenced by the current module, not just from those that are imported explicitly (#667).?Desugars import declarations from AST to CoreFn representation.@Desugars foreign declarations from AST to CoreFn representation.Desugars export declarations references from AST to CoreFn representation. CoreFn modules only export values, so all data constructors, class constructor, instances and values are flattened into one list.Makes a typeclass dictionary constructor function. The returned expression is a function that accepts the superclass instances and member implementations and returns a record for the instance dictionary."Converts a ProperName to an Ident.7777jNone(8 !"#$%     7DNone(4N$The state object used in this moduleDA map from names bound (in the input) to their names (in the output)DThe set of names which have been used and are in scope in the outputCRuns renaming starting with a list of idents for the initial scope.bCreates a new renaming scope using the current as a basis. Used to backtrack when leaving an Abs.qAdds a new scope entry for an ident. If the ident is already present, a new unique name is generated and stored.'Finds the new name to use for an ident.(Finds idents introduced by declarations.8,Renames within each declaration in a module.PRenames within a declaration. isTopLevel is used to determine whether the declaration is a module member or appearing within a Let. At the top level declarations are not renamed or added to the scope (they should already have been added), whereas in a Let declarations are renamed if their name shadows another in the current scope.Renames within a value.Renames within literals.!Renames within case alternatives.Renames within binders.8888ENone !"(4N9iGenerate code in the simplified Javascript intermediate representation for all declarations in a module.9Jlmnopqrstuvwxyz{|}~999kNone(Jlmnopqrstuvwxyz{|}~9FNone(4N: Replace all DoNotationBind and DoNotationValueG constructors with applications of the Prelude.bind function, and all  DoNotationLet# constructors with let expressions.::::GNone(4N;;;;HNone(4FIN<DRemove explicit parentheses and reorder binary operator applications<=><=><=><=>INone(47GIN?=Elaborates deriving instance declarations by code generation.Takes a declaration, and if the declaration is a deriving TypeInstanceDeclaration, elaborates that into an instance declaration via code generation.????JNone(4N@IReplace all top level type declarations in a module with type annotations@@@@KNone(4FINUALFinds all exportable members of a module, disregarding any explicit exports.BResolves the exports for a module, filtering out members that have not been exported and elaborating re-exports of other modules.~Filters the full list of exportable values, types, and classes for a module based on a list of export declaration references.ABABABABLNone(4FNCReplaces all local names with qualified names within a list of modules. The modules should be topologically sorted beforehand.Make 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.vReplaces all local names with qualified names within a module and checks that all existing qualified names are valid. Replaces  export values with a  or @ depending on what is availble within the module. Warns when a  desugars into a .CDCDCDCDMNone(4E,The desugaring pipeline proceeds as follows: $Remove signed literals in favour of  applications3Desugar object literals with wildcards into lambdasDesugar operator sectionsDesugar do-notation using the  Prelude.Monad type classBDesugar top-level case declarations into explicit case expressionsPDesugar type declarations into value declarations with explicit type annotations'Qualify any unqualified names and types'Rebracket user-defined binary operators3Introduce type synonyms for type class dictionariesIGroup mutually recursive value and data declarations into binding groups.E!./0123456:;<=>?@CDEEENNone(4NF+Ensure rows do not contain duplicate labelsFFFFONone(4GGenerate a new skolem constantH5Introduce skolem scope at every occurence of a ForAllIGenerate a new skolem scopeJPSkolemize a type variable by replacing its instances with fresh skolem constantsKThis 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.L1Ensure skolem variables do not escape their scopeGHIJKLGHIJKLGHIJKLGHIJKLPNone(3457N MGenerate a fresh type variableN2Update the substitution to solve a type constraintOApply a substitution to a type2Make sure that an unknown does not occur in a type2Compute a list of all unknowns appearing in a typeP2Unify two types, updating the current substitutionQ1Unify two rows, updating the current substitutionCommon labels are first identified, and unified. Remaining labels and types are unified with a trailing row unification variable, if appropriate, otherwise leftover labels result in a unification error.RCheck that two types unifyS>Replace a single type variable with a new unification variableT$Replace type wildcards with unknownsUJReplace outermost unsolved unification variables with named type variables MNOPQRSTU MNOPQRSTU MNOPQRSTU MNOPQRSTUQNone(4NVCheck that the current set of type class dictionaries entail the specified type class goal, and, if so, return a type class dictionary reference.Check whether the type heads of two types are equal (for the purposes of type class dictionary lookup), and return a substitution from type variables to types which makes the type heads unify.5Check all values in a list pairwise match a predicateVVVVRNone(4WYCheck that one type subsumes another, rethrowing errors to provide a better error message%Check tahat one type subsumes anotherWWWWSNone(47NXInfer the types of multiple mutually-recursive values, and return elaborated values including type class dictionaries and type annotations.+Check if a value contains a type annotation=Map a function over type annotations appearing inside a valuePReplace type class dictionary placeholders with inferred type class dictionaries9Check the kind of a type, failing if it is not of kind *.yRemove any ForAlls and ConstrainedType constructors in a type by introducing new unknowns or TypeClassDictionary values.iThis is necessary during type checking to avoid unifying a polymorphic type with a unification variable.UInfer a type for a value, rethrowing any error to provide a more useful error messageInfer a type for a value;Infer the types of variables brought into scope by a binderReturns true if a binder requires its argument type to be a monotype. | If this is the case, we need to instantiate any polymorphic types before checking binders.9Instantiate polytypes only when necessitated by a binder.LCheck the types of the return values in a set of binders in a case statementNCheck the type of a value, rethrowing errors to provide a better error messageCheck the type of a value5Check the type of a collection of named record fieldsThe laxt parameter controls whether or not every record member has to be provided. For object updates, this is not the case.]Check the type of a function application, rethrowing errors to provide a better error message(Check the type of a function applicationqCompute the meet of two types, i.e. the most general type which both types subsume. TODO: is this really needed?JEnsure a set of property names and value does not contain duplicate labelsXXXXTNone(345N4Check that type synonyms are fully-applied in a type'Type check all declarations in a moduleWAt 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 scopeProcess module importsYType check an entire module and ensure all types and classes defined within the module that are required by exported members are also exported. Y.      !"#$%&'()*+,-XYY YUNone(47>CFILNZ A monad for running make actions]#Determines when to rebuild a module^Never rebuild this module_Always rebuild this module`#Generated code for an externs file.aAActions that require implementations when running in "make" mode.-This type exists to make two things abstract:;The particular backend being used (Javascript, C++11, etc.).The details of how files are read/written etc.cGet the timestamp for the input file(s) for a module. If there are multiple files (.purs and foreign files, for example) the timestamp should be for the most recently modified file.dGet the timestamp for the output files for a module. This should be the timestamp for the oldest modified file, or Nothing if any of the required output files are missing.e]Read the externs file for a module as a string and also return the actual path for the file.fJRun the code generator for the module and write any required output files.gRespond to a progress update.h'Progress messages from the make processjRender a progress messagek[Compiles in "make" mode, compiling each module separately to a js files and an externs fileIf timestamps have not changed, the externs file can be used to provide the module's types without having to typecheck the module again.l Execute a ZP monad, returning either errors, or the result of the compile plus any warnings.mKA set of make actions that read and write modules from the given directory.Z[\]^_`abcdefghijklmthe output directoryQa map between module names and paths to the file containing the PureScript moduleWa map between module name and the file containing the foreign javascript for the moduleGenerate a prefix comment?Z[\]^_`abcdefghijklm]^_hijabcdefg`kZ[\lmZ[\]^_`abcdefghijklmVNone(4Nn !"#$%&')*+,-./0123456789:;<=>?@ABCDEFGHIJKLZ[\^_`abcdefghijk      !"#$%&'()*+,-./0123459:;<=>?@ABCDEIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./01234568:;<=>?@CDEXYZ[\]^_`abcdefghijklmnnnWNone(CoA type representing a highly simplified version of PureScript code, intended for use in output formats like plain text or HTML.pThis type is isomorphic to  G. It makes code a bit easier to read, as the meaning is more explicit.sA single element in a rendered code fragment. The intention is to support multiple output formats. For example, plain text, or highlighted HTML.| Convert a   to a p!, using the obvious isomorphism.} Convert a p to a  !, using the obvious isomorphism.~ A version of  fromMaybe for p values.%This function allows conversion of a o value into a value of some other type (for example, plain text, or HTML). The first argument is a function specifying how each individual s should be rendered.A o fragment representing a space.%opqrstuvwxyz{|}~ opqrstuvwxyz{|}~ stuvwxyzpqr{}|~oopqrstuvwxyz{|}~XNone(Render code representing a RowRender code representing a KindGRender code representing a Type, as it should appear inside parenthesesRender code representing a Type            lNone(*opqrstuvwxyz{|}~YNone(FIN`Minimum allowable version for generating data with the current parser, and actual version used.@A type instance declaration, with its dependencies and its type.,A data constructor, with its type arguments.A type class member, with its type. Note that the type does not include the type class constraint; this may be added manually if desired. For example,  from  would be `forall a. a -> f a`.A value of this type contains information that is specific to a particular kind of declaration (as opposed to information which exists in all kinds of declarations, which goes into the  type directly).Many of the constructors are very similar to their equivalents in the real PureScript AST, except that they have their name elided, since this is already available via the rdTitle field of .#A value declaration, with its type.A data/newtype declaration, with the kind of declaration (data or newtype) and its type arguments. Constructors are represented as child declarations.*A data type foreign import, with its kind.5A type synonym, with its type arguments and its type.yA type class, with its type arguments and its superclasses. Instances and members are represented as child declarations.[An operator alias declaration, with the member the alias is for and the operator's fixity.The version of the PureScript compiler which was used to generate this data. We store this in order to reject packages which are too old.>Discard any children which do not satisfy the given predicate. Given a function for turning association list keys into JSON object keys, and a function for turning association list values to JSON string values, turns an association list into a JSON object.For example: *assocListToJSON T.pack T.pack [("a", "b")] will give  {"a": "b"}.     opqrstuvwxyz{      L      ZNone(  !"  !"  !"  !"[None (4FESome data which will be used to augment a Declaration in the output.oThe AugmentChild constructor allows us to move all children under their respective parents. It is only necessary for type instance declarations, since they appear at the top level in the AST, and since they might need to appear as children in two places (for example, if a data type defined in a module is an instance of a type class also defined in that module).qThe AugmentFixity constructor allows us to augment operator definitions with their associativity and precedence.OThe data type for an intermediate stage which we go through during converting.In the first pass, we take all top level declarations in the module, and collect other information which will later be used to augment the top level declarations. These two situation correspond to the Right and Left constructors, respectively.In the second pass, we go over all of the Left values and augment the relevant declarations, leaving only the augmented Right values.uNote that in the Left case, we provide a [String] as well as augment information. The [String] value should be a list of titles of declarations that the augmentation should apply to. For example, for a type instance declaration, that would be any types or type classes mentioned in the instance. For a fixity declaration, it would be just the relevant operator's name.#oConvert a single Module, but ignore re-exports; any re-exported types or values will not appear in the result.Augment top-level declarations; the second pass. See the comments under the type synonym IntermediateDeclaration for more information.`Add the default operator fixity for operators which do not have associated fixity declarations.UTODO: This may no longer be necessary after issue 806 is resolved, hopefully in 0.9.!Create a basic Declaration value.$Go through a PureScript module and extract a list of Bookmarks; references to data types or values, to be used as a kind of index. These are used for generating links in the HTML documentation, for example.#$#$#$ #$\None (4F An intermediate data type, used for either moving type class members under their parent type classes, or promoting them to normal Declaration values if their parent type class has not been re-exported.!Type class members which have not yet been dealt with. The String is the name of the type class they belong to, and the constraint is used to make sure that they have the correct type if they get promoted."A list of normal value declarations. Type class members will be added to this list if their parent type class is not available.#rA list of type class declarations. Type class members will be added to their parents in this list, if they exist.%Given:The Imports/Exports Env<An order to traverse the modules (which must be topological)iA map of modules, indexed by their names, which are assumed to not have their re-exports listed yet.This function adds all the missing re-exports.$@Collect all of the re-exported declarations for a single module.We require that modules have already been sorted (P.sortModules) in order to ensure that by the time we convert a particular module, all its dependencies have already been converted.%Assemble a list of declarations re-exported from a particular module, based on the Imports and Exports value for that module, and by extracting the declarations from the current state.This function works by searching through the lists of exported declarations in the Exports, and looking them up in the associated Imports value to find the module they were imported from. Additionally:Attempts to move re-exported type class members under their parent type classes, if possible, or otherwise, "promote" them from ChildDeclarations to proper Declarations.]Filters data declarations to ensure that only re-exported data constructors are listed.dFilters type class declarations to ensure that only re-exported type class members are listed.&Given a list of imported declarations (of a particular kind, ie. type, data, class, value, etc), and the name of an exported declaration of the same kind, together with the module it was originally defined in, return a tuple of:the module that exported declaration was imported from (note that this can be different from the module it was originally defined in, if it is a re-export),that same declaration's name.XThis function uses a type variable for names because we want to be able to instantiate name as both  and .'Extract a particular type declaration. For data declarations, constructors are only included in the output if they are listed in the arguments.({Get the full list of declarations for a particular module out of the state, or raise an internal error if it is not there.)Take a TypeClassEnv and handle all of the type class members in it, either adding them to their parent classes, or promoting them to normal Declaration values.*Returns a tuple of (values, type classes).*Given a list of exported constructor names, remove any data constructor names in the provided Map of declarations which are not in the list.+Given a list of exported type class member names, remove any data type class member names in the provided Map of declarations which are not in the list.,If the provided Declaration is a TypeClassDeclaration, construct an appropriate Constraint for use with the types of its members. -!"#%$%&.'/(012)3*+45678,9%% -!"#%$%&.'/(012)3*+45678,9]None (4F&Like convertModules, except that it takes a list of modules, together with their dependency status, and discards dependency modules in the resulting documentation.'Convert a group of modules to the intermediate format, designed for producing documentation from. It is also necessary to pass an Env containing imports/exports information about the list of modules, which is needed for documenting re-exports.Preconditions:|If any module in the list re-exports documentation from other modules, those modules must also be included in the list.VThe modules passed must have had names desugared and re-exports elaborated first.If either of these are not satisfied, an internal error will be thrown. To avoid this, it is recommended to use Language.PureScript.Docs.ParseAndDesugar to construct the inputs to this function.:!Convert a sorted list of modules.&':$&''&$&':^None(4F;<Specifies whether a PureScript source file is considered as: 1) with the d constructor, a target source file, i.e., we want to see its modules in the output 2) with the  constructor, a dependencies source file, i.e. we do not want its modules in the output; it is there to enable desugaring, and to ensure that links between modules are constructed correctly.(Given:A list of local source filesZA list of source files from external dependencies, together with their package names!This function does the following:2Parse all of the input and dependency source filesmAssociate each dependency module with its package name, thereby distinguishing these from local moduleshPartially desugar all of the resulting modules (just enough for producing documentation from them)>Collect a list of bookmarks from the whole set of source files}Return the desugared modules, the bookmarks, and the imports/exports Env (which is needed for producing documentation). ;(<=>?@ABCDEF(( ;(<=>?@ABCDEFmNone(opqrstuvwxyz{|}~  !"$&'(_None(4*cTake a list of modules and render them all in order, returning a single Markdown-formatted String.)GHI*+JKLMN,OPQRS)*+,*),+)GHI*+JKLMN,OPQRS`None(36An error that probably indicates a bug in this module.9*An error that should be fixed by the user.HRAn error which meant that it was not possible to retrieve metadata for a package.4TUVWXY-./0123456789:;<=>?@ABCDEFGHIJKLMZ[\]^_N`abcOd#-./0123456789:;<=>?@ABCDEFGHIJKLMNO#HIJKCDEFG9:;<=>?@AB34-./5678012LMONTUVWXY-./0123456789 :;<=>?@ABCDEFGHIJKLMZ[\]^_N`abcOdaNone(CF e(Listed in bower.json, but not installed.fIn the output of `bower list --json --offline`, there was no _resolution key. This can be caused by adding the dependency using `bower link`, or simply copying it into bower_components instead of installing it normally.gResolved, but to something other than a version. The String argument is the resolution type. The values it can take that I'm aware of are "commit" and "branch".hQResolved to a version. The String argument is the resolution tag (eg, "v0.1.0").SWHow to obtain the version tag and version that the data being generated will refer to.T)What to do when the working tree is dirtyV~Attempt to retrieve package metadata from the current directory. Calls exitFailure if no package metadata could be retrieved.iRExtracts all dependencies and their versions from `bower list --json --offline`j`Extracts only the top level dependency names from the output of `bower list --json --offline`k`Returns whether it looks like there is a purescript package checked out in the given directory.,lefghmnoPpqQRSTUVWXYZ[r\]^_`astbuijvwxykz{|}PQRSTUVWXYZ[\]^_`abV\PWXYZ[QRSTU^_`a]b!lefghmnoPpqQRSTUVWXYZ[r\]^_`astbuijvwxykz{|}~nopnoqrstuvwxyz{|}~                             ! " # $ % & ' ( ) * + , , - . / 0 1 2 3 4 5 67789:;<=>?@@AABCDEFGGHIIJKLMNOPQRSTUVWXYZ[\]^_`abcdeefghijklmnopqrstuvwxyz{|}~_`bcd     (  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH(IJKLMNOuPQR S!T!T!$!!U!V!W!X!Y!Z!["\#]#^#_#`#a#b#c#d#e#f#g#h#i#j#k#l#m#m#n#o#p#q#r#s#t#u#v#w#x#y#z#{#|#}#~#############$$$$%%%%%%%%%%%%&&&&&&e&e&f&g&l&&&&&&&&&&&&&n&o&&p&q&r&&m&s&&t&&&&&&&h&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& & &&&&&&&&&&&&&&&&&&&&'x'''y''''(()))))))))))))*************+,,,,,,, , - - - ./00000012222222222 2!2"2#2$2%2&2'2(2)2*2+2,2-2.2/2021222323242526272828292:2;2<2<2=2>2?2@2A2B2C2D3E3F3G4H4I4J4K4K4L4M4N4O4P4P4Q4R4R4"4"4S4T4U4V4W4X4Y4Z4[4'4\4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}4~4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444$444444444445567777777777 7 7 7 7 7777777777788899999 9!9":#;$;%;&;';(;);*;+;,;-<.</=0=1=1=2=3=4=5=6=7=8=9=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^A_B`BaBbCcDdEeFfGgHhHiHjIkJlKmKnLdLoMpNqOrOsOtOuOvOwPxPyPzP{P|P}P~PPQRSTUcUcUUUUUUUUUUUUUUUUUUVWWWWWWWIWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY Y YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY Y Y Y Y YYYYYYYYYYYYYYYYYYY Y!Y"Y#Y$Y%Y&Y'Y(Y)Y*Y+Y,Y-Y.Z/Z0Z1Z2Z3Z4Z5Z6Z7Z8Z9[:[;\<]=]>^?_@_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`[`\`]`^``P`J`D`_```a`bacadadaeafagahaiajaka\alamanaoapaqarasbtbbubvbwbxbybzb{b|b}b~b                       $$$$$$$$$$$((((++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,..///000080000000111111111111111122223333333556666 6 6 6 6 66666067778899999999 9!9"9#;$;%;&;';(;);*;+;,;;-;.;/;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@rAsAtAuAvAwAxAyBzB{B|B}B~BBBBCCCCCCDDDDDDDDDDDDDDDDFHHHHHHHHHHH*HHHIIIIIIIIIIIIIIIIIIIIKLLLPbPQQRSSSSSSfShSSSSSSSSSSSSSSSSSTTTTTTTTTTTUUUUUWWWWWXXXXX8XXXXXXXXXX[[[[[[[[[[[[\\\\\\\\\ \ \\ \ \\ \\\\\\\\\\\\]^^^^^^^^p^^^ ^!_"_"_#_$_%_&_'_(_)_x_*_+_,`-`-`.`/`0`1`2`3`4`5`6`7`8`9`:`;`<a=a>a?a@aaAaBaCaDaEaFacaGaHaIaJaKaLaMaNaOaPaQaRaSTpures_DLr64qZp0ZfCIcqNjCXlaG(Language.PureScript.Publish.BoxesHelpers!Language.PureScript.Publish.Utils+Language.PureScript.Docs.Utils.MonoidExtras Language.PureScript.Parser.StateSystem.IO.UTF8Control.Monad.Logger#Language.PureScript.CoreFn.LiteralsLanguage.PureScript.ConstantsLanguage.PureScript.Traversals!Language.PureScript.AST.SourcePosLanguage.PureScript.BundleControl.Monad.SupplyControl.Monad.Supply.ClassLanguage.PureScript.OptionsLanguage.PureScript.Names"Language.PureScript.CoreFn.BindersLanguage.PureScript.CoreFn.Expr%Language.PureScript.CoreFn.TraversalsLanguage.PureScript.CoreFn.MetaLanguage.PureScript.KindsLanguage.PureScript.Types)Language.PureScript.TypeClassDictionariesLanguage.PureScript.CommentsLanguage.PureScript.AST.Binders"Language.PureScript.CodeGen.JS.AST,Language.PureScript.CodeGen.JS.Optimizer.TCO/Language.PureScript.CodeGen.JS.Optimizer.BlocksLanguage.PureScript.CoreFn.Ann!Language.PureScript.CoreFn.Module Language.PureScript.Parser.Lexer!Language.PureScript.Parser.Common Language.PureScript.Parser.Kinds!Language.PureScript.Pretty.CommonLanguage.PureScript.CrashLanguage.PureScript.Environment Language.PureScript.Parser.Types!Language.PureScript.AST.Operators$Language.PureScript.AST.Declarations"Language.PureScript.AST.Traversals Language.PureScript.AST.Exported%Language.PureScript.CodeGen.JS.Common/Language.PureScript.CodeGen.JS.Optimizer.Common0Language.PureScript.CodeGen.JS.Optimizer.MagicDo0Language.PureScript.CodeGen.JS.Optimizer.Inliner/Language.PureScript.CodeGen.JS.Optimizer.Unused(Language.PureScript.CodeGen.JS.Optimizer Language.PureScript.Pretty.Kinds Language.PureScript.Pretty.TypesLanguage.PureScript.Pretty.JSLanguage.PureScript.Externs!Language.PureScript.Pretty.ValuesLanguage.PureScript.Errors&Language.PureScript.ModuleDependencies%Language.PureScript.Linter.Exhaustive#Language.PureScript.Sugar.Names.Env'Language.PureScript.Sugar.Names.Imports"Language.PureScript.Linter.ImportsLanguage.PureScript.Linter'Language.PureScript.Parser.DeclarationsLanguage.PureScript.Parser.JS%Language.PureScript.TypeChecker.Monad%Language.PureScript.TypeChecker.Kinds(Language.PureScript.TypeChecker.Synonyms'Language.PureScript.Sugar.BindingGroups*Language.PureScript.Sugar.CaseDeclarations%Language.PureScript.Sugar.TypeClasses"Language.PureScript.CoreFn.DesugarLanguage.PureScript.RenamerLanguage.PureScript.CodeGen.JS$Language.PureScript.Sugar.DoNotation)Language.PureScript.Sugar.ObjectWildcards#Language.PureScript.Sugar.Operators.Language.PureScript.Sugar.TypeClasses.Deriving*Language.PureScript.Sugar.TypeDeclarations'Language.PureScript.Sugar.Names.ExportsLanguage.PureScript.Sugar.NamesLanguage.PureScript.Sugar$Language.PureScript.TypeChecker.Rows'Language.PureScript.TypeChecker.Skolems%Language.PureScript.TypeChecker.Unify*Language.PureScript.TypeChecker.Entailment+Language.PureScript.TypeChecker.Subsumption%Language.PureScript.TypeChecker.TypesLanguage.PureScript.TypeCheckerLanguage.PureScript.MakeLanguage.PureScript+Language.PureScript.Docs.RenderedCode.Types,Language.PureScript.Docs.RenderedCode.RenderLanguage.PureScript.Docs.TypesLanguage.PureScript.Docs.Render'Language.PureScript.Docs.Convert.Single*Language.PureScript.Docs.Convert.ReExports Language.PureScript.Docs.Convert(Language.PureScript.Docs.ParseAndDesugar#Language.PureScript.Docs.AsMarkdown*Language.PureScript.Publish.ErrorsWarningsLanguage.PureScript.PublishPaths_purescriptMakedesugarImportsLanguage.PureScript.ASTLanguage.PureScript.PrettyText.Parsec.ErrorshowErrorMessagesLanguage.PureScript.ParserLanguage.PureScript.CoreFnLanguage.PureScript.CodeGen%Language.PureScript.Docs.RenderedCodeLanguage.PureScript.Docsboxes_2Qd0ax8EpiG0k7TLjDyTb7Text.PrettyPrint.BoxesnullBoxBoxwidth indentWidthparaindentedsuccessivelyIndentedvcatspacer bulletedList printToStderr globRelativepurescriptSourceFilespurescriptDepsFiles mintersperse ParseStateindentationLevel readUTF8File writeUTF8FileLogger runLogger runLogger'$fMonadBaseControlIOLogger$fMonadBaseIOLogger$fMonadWriterwLogger$fMonadIOLogger $fMonadLogger$fApplicativeLogger$fFunctorLoggerLiteralNumericLiteral StringLiteral CharLiteralBooleanLiteral ArrayLiteral ObjectLiteral$apply# applyFlipped<>++append>>=bind+add-sub*mul/div%mod<lessThan> greaterThan<= lessThanOrEq>=greaterThanOrEq==eq/=notEq&&conj||disj unsafeIndex.|..&..^.<<<compose>>>composeFlippednegatenotshlshrzshr complementzeroonebottomtopreturnpure' returnEscapeduntilEwhileErunST stRefValuenewSTRef readSTRef writeSTRef modifySTRefmkFnrunFnunit undefinedmonadEffDictionaryapplicativeEffDictionarybindEffDictionarysemiringNumber semiringInt ringNumberringIntmoduloSemiringNumbermoduloSemiringInt ordBoolean ordNumberordInt ordStringordChareqNumbereqInteqStringeqChar eqBooleanboundedBooleanbooleanAlgebraBooleansemigroupStringsemigroupoidFngenerictoSpine fromSpine toSignaturemain __superclass___unusedprimpreludedataArrayUnsafeeffstcontrolApplicativecontrolSemigroupoid controlBind dataBounded dataSemigroupdataModuloSemiringdataBooleanAlgebradataEqdataOrd dataSemiringdataRing dataFunction dataIntBitsfstMsndMthirdMpairMmaybeMeitherMdefS SourceSpanspanName spanStartspanEnd SourcePos sourcePosLinesourcePosColumndisplaySourcePosdisplayStartEndPosdisplaySourceSpaninternalModuleSourceSpan$fFromJSONSourceSpan$fToJSONSourceSpan$fFromJSONSourcePos$fToJSONSourcePosModuleIdentifier ModuleTypeRegularForeign ErrorMessageUnsupportedModulePathInvalidTopLevelUnableToParseModuleUnsupportedExport ErrorInModule moduleNameprintErrorMessagebundleSupplySupplyT unSupplyT runSupplyT evalSupplyT runSupply evalSupply MonadSupplyfresh freshName$fMonadSupplyStateT$fMonadSupplySupplyTOptions optionsNoTcooptionsNoMagicDo optionsMainoptionsNoOptimizationsoptionsVerboseErrorsoptionsNoCommentsoptionsRequirePathdefaultOptions Qualified ModuleNameProperNameTypeTypeNameConstructorName ClassName Namespace ProperName runProperNameIdentOpGenIdentrunIdent showIdent freshIdent freshIdent'coerceProperName runModuleNamemoduleNameFromString showQualifiedqualify mkQualified disqualify isQualified isUnqualifiedisQualifiedWith$fFromJSONProperName$fToJSONProperName$fFromJSONQualified$fFromJSONIdent$fFromJSONModuleNameBinder NullBinder LiteralBinder VarBinderConstructorBinder NamedBinderCaseAlternativecaseAlternativeBinderscaseAlternativeResultGuardBindNonRecRecExpr ConstructorAccessor ObjectUpdateAbsAppVarCaseLet extractAnn modifyAnn$fFunctorCaseAlternativeeverywhereOnValueseverythingOnValuesConstructorType ProductTypeSumTypeMeta IsConstructor IsNewtypeIsTypeClassConstructor IsForeignKindKUnknownStarBangRowFunKindeverywhereOnKindseverywhereOnKindsMeverythingOnKinds$fFromJSONKind ConstraintTypeTUnknownTypeVar TypeWildcardTypeConstructorTypeAppForAllConstrainedTypeSkolemREmptyRCons KindedTypePrettyPrintFunctionPrettyPrintObjectPrettyPrintForAll SkolemScoperunSkolemScope rowToList rowFromList isMonoTypemkForAllreplaceTypeVarsreplaceAllTypeVarsusedTypeVariablesfreeTypeVariablesquantifymoveQuantifiersToFrontcontainsWildcardseverywhereOnTypeseverywhereOnTypesTopDowneverywhereOnTypesMeverywhereOnTypesTopDownMeverythingOnTypeseverythingWithContextOnTypes$fFromJSONTypeDictionaryValueLocalDictionaryValueGlobalDictionaryValueDependentDictionaryValueSubclassDictionaryValueTypeClassDictionaryInScopetcdNametcdPath tcdClassNametcdInstanceTypestcdDependenciesComment LineComment BlockComment$fFromJSONComment BooleanBinder StringBinder CharBinder NumberBinder ObjectBinder ArrayBinderPositionedBinder TypedBinder binderNamesJSJSNumericLiteralJSStringLiteralJSBooleanLiteralJSUnaryJSBinaryJSArrayLiteral JSIndexerJSObjectLiteral JSAccessor JSFunctionJSAppJSVar JSConditionalJSBlockJSVariableIntroduction JSAssignmentJSWhileJSForJSForInJSIfElseJSReturnJSThrowJSTypeOf JSInstanceOfJSLabelJSBreak JSContinueJSRaw JSCommentBinaryOperatorAddSubtractMultiplyDivideModulusEqualTo NotEqualToLessThanLessThanOrEqualTo GreaterThanGreaterThanOrEqualToAndOr BitwiseAnd BitwiseOr BitwiseXor ShiftLeft ShiftRightZeroFillShiftRight UnaryOperatorNegateNot BitwiseNotPositiveJSNeweverywhereOnJSeverywhereOnJSTopDowneverywhereOnJSTopDownMeverythingOnJStcocollapseNestedBlockscollapseNestedIfsAnnnullAnnremoveComments ForeignDeclModulemoduleComments moduleImports moduleExports moduleForeign moduleDecls TokenParserPositionedToken ptSourcePosptToken ptCommentsTokenlexanyTokentokenmatchlparenrparenparenslbracerbracebraceslsquarersquaresquaresindentindentAtlarrowrarrow lfatArrow rfatArrowcolon doubleColonequalspipetickdotcommasemiat underscoresemiSepsemiSep1commaSep commaSep1lname qualifierreservedunamemnameuname'symbolsymbol' charLiteral stringLiteralnumbernatural identifierreservedPsNamesreservedTypeNames isSymbolChar properNameparseQualified parseIdentaugmentfoldbuildPostfixParsermarkcheckIndentationsame readCommentsrunTokenParser parseKind PrinterState blockIndent withIndent currentIndentprettyPrintManyprettyPrintObjectKeybeforebeforeWithSpace internalError DataDeclTypeDataNewtypeTypeKindDataType TypeSynonym ExternDataLocalTypeVariable ScopedTypeVarNameKindPrivatePublicExternalNameVisibility UndefinedDefined EnvironmentnamestypesdataConstructors typeSynonymstypeClassDictionaries typeClassesinitEnvironmentshowDataDeclTypeprimNameprimTy tyFunctiontyStringtyChartyNumbertyInt tyBooleantyArraytyObjectisObject isFunctionisTypeOrAppliedfunction primTypes primClasseslookupConstructorisNewtypeConstructor lookupValue$fFromJSONDataDeclType$fToJSONDataDeclType$fFromJSONTypeKind parseTypeAtom parseType parsePolyType noWildcardsFixity AssociativityInfixlInfixrInfix Precedence showAssoc readAssoc$fToJSONFixity$fFromJSONAssociativity$fToJSONAssociativityDoNotationElementDoNotationValueDoNotationBind DoNotationLetPositionedDoNotationElement UnaryMinusBinaryNoParensParensOperatorSectionObjectConstructor ObjectGetter ObjectUpdater IfThenElse TypedValueDo!TypeClassDictionaryConstructorAppTypeClassDictionaryTypeClassDictionaryAccessorSuperClassDictionaryPositionedValueTypeInstanceBodyDerivedInstanceExplicitInstance DeclarationDataDeclarationDataBindingGroupDeclarationTypeSynonymDeclarationTypeDeclarationValueDeclarationBindingGroupDeclarationExternDeclarationExternDataDeclarationFixityDeclarationImportDeclarationTypeClassDeclarationTypeInstanceDeclarationPositionedDeclarationImportDeclarationTypeImplicitExplicitHidingDeclarationRefTypeRefValueRef TypeClassRefTypeInstanceRef ModuleRef ProperRefPositionedDeclarationRef getModuleNameaddDefaultImport isModuleReffindDuplicateRefs isImplicit isExplicitmapTypeInstanceBodytraverseTypeInstanceBody isValueDecl isDataDecl isImportDeclisExternDataDecl isFixityDecl isExternDeclisTypeClassInstanceDeclarationisTypeClassDeclaration flattenDecls$fEqDeclarationRef$fFromJSONDeclarationRef$fFromJSONImportDeclarationTypeeverywhereOnValuesTopDownMeverywhereOnValuesMeverythingWithContextOnValueseverywhereWithContextOnValuesMeverythingWithScope accumTypesexportedDeclarations isExportedmoduleNameToJs identToJsidentNeedsEscapingidentCharToStringnameIsJsReservednameIsJsBuiltIn jsAnyReserved jsKeywordsjsSometimesReservedjsFutureReservedjsFutureReservedStrict jsOldReserved jsLiteralsapplyAll replaceIdent replaceIdents isReassigned isReboundisUsedtargetVariable isUpdatedremoveFromBlockisFnisFn'isDictisDict'magicDo etaConvertunThunk evaluateIifesinlineVariablesinlineCommonValuesinlineOperatorinlineCommonOperatorsinlineFnCompositionremoveCodeAfterReturnStatementsremoveUnusedArgremoveUndefinedAppoptimizeprettyPrintKindprettyPrintRowWithprettyPrintRow typeAtomAsBoxprettyPrintTypeAtom typeAsBoxprettyPrintType prettyPrintJSExternsDeclarationEDType edTypeName edTypeKindedTypeDeclarationKind EDTypeSynonymedTypeSynonymNameedTypeSynonymArgumentsedTypeSynonymTypeEDDataConstructoredDataCtorNameedDataCtorOriginedDataCtorTypeCtoredDataCtorTypeedDataCtorFieldsEDValue edValueName edValueTypeEDClass edClassNameedClassTypeArgumentsedClassMembersedClassConstraints EDInstanceedInstanceClassNameedInstanceNameedInstanceTypesedInstanceConstraints ExternsFixityefAssociativity efPrecedence efOperatorefAlias ExternsImporteiModule eiImportType eiImportedAs ExternsFile efVersion efModuleName efExports efImports efFixitiesefDeclarationsapplyExternsFileToEnvironmentmoduleToExternsFileprettyPrintValueprettyPrintBinderAtomprettyPrintBinderLevelErrorWarningTypeMap umSkolemMap umNextSkolem umUnknownMap umNextUnknownMultipleErrorsrunMultipleErrorsErrorSuggestion HintCategoryExprHintKindHint CheckHint PositionHint OtherHintErrorMessageHintErrorUnifyingTypesErrorInExpressionErrorInInstanceErrorInSubsumptionErrorCheckingAccessorErrorCheckingTypeErrorCheckingKindErrorCheckingGuardErrorInferringTypeErrorInApplicationErrorInDataConstructorErrorInTypeConstructorErrorInBindingGroupErrorInDataBindingGroupErrorInTypeSynonymErrorInValueDeclarationErrorInTypeDeclarationErrorInForeignImportPositionedErrorSimpleErrorMessageErrorParsingFFIModuleErrorParsingModuleMissingFFIModuleMultipleFFIModulesUnnecessaryFFIModuleCannotGetFileInfoCannotReadFileCannotWriteFile InfiniteType InfiniteKindMultipleFixitiesOrphanTypeDeclarationOrphanFixityDeclarationRedefinedModuleRedefinedIdentOverlappingNamesInLet UnknownModule UnknownTypeUnknownTypeClass UnknownValueUnknownDataConstructorUnknownTypeConstructorUnknownImportTypeUnknownExportTypeUnknownImportTypeClassUnknownExportTypeClassUnknownImportValueUnknownExportValueUnknownExportModuleUnknownImportDataConstructorUnknownExportDataConstructor ScopeConflictConflictingTypeDeclsConflictingCtorDeclsTypeConflictsWithClassCtorConflictsWithClassClassConflictsWithTypeClassConflictsWithCtorDuplicateModuleNameDuplicateClassExportDuplicateValueExportDuplicateTypeArgument InvalidDoBind InvalidDoLetCycleInDeclarationCycleInTypeSynonymCycleInModulesNameIsUndefinedUndefinedTypeVariablePartiallyAppliedSynonym EscapedSkolemTypesDoNotUnifyKindsDoNotUnifyConstrainedTypeUnifiedOverlappingInstancesNoInstanceFoundPossiblyInfiniteInstance CannotDeriveCannotFindDerivingTypeDuplicateLabelDuplicateValueDeclarationArgListLengthsDifferOverlappingArgNamesMissingClassMemberExtraneousClassMember ExpectedTypeIncorrectConstructorArityExprDoesNotHaveTypePropertyIsMissingAdditionalPropertyCannotApplyFunctionTypeSynonymInstanceOrphanInstanceInvalidNewtypeInvalidInstanceHeadTransitiveExportError ShadowedNameShadowedTypeVar UnusedTypeVarWildcardInferredTypeMissingTypeDeclarationNotExhaustivePatternOverlappingPatternIncompleteExhaustivityCheck ClassOperatorMisleadingEmptyTypeImportImportHidingModule UnusedImportUnusedExplicitImportUnusedDctorImportUnusedDctorExplicitImportDeprecatedOperatorDeclDeprecatedQualifiedSyntaxDeprecatedClassImportDeprecatedClassExportRedundantUnqualifiedImportDuplicateSelectiveImportDuplicateImportDuplicateImportRefDuplicateExportRef IntOutOfRangeRedundantEmptyHidingImportImplicitQualifiedImportImplicitImport HidingImportCaseBinderLengthDiffers errorSpan errorModulefindHintstripModuleAndSpan errorCodenonEmpty errorMessage singleErroronErrorMessagesaddHintdefaultUnknownMapunwrapErrorMessagereplaceUnknownsonTypesInErrorMessageMwikiUrierrorSuggestionshowSuggestionprettyPrintSingleErrorprettyPrintExportprettyPrintImportprettyPrintRefprettyPrintMultipleErrorsprettyPrintMultipleWarningsprettyPrintMultipleWarningsBoxprettyPrintMultipleErrorsBoxprettyPrintMultipleErrorsWithprettyPrintParseErrorprettyPrintParseErrorMessagesline renderBoxrethrow reifyErrors reflectErrorswarnAndRethrowrethrowWithPositionwarnWithPositionwarnAndRethrowWithPosition withPositionparU ModuleGraph sortModulescheckExhaustiveModuleEnvExports exportedTypesexportedTypeClassesexportedValuesImports importedTypesimportedDataConstructorsimportedTypeClassesimportedValuesimportedModulesimportedVirtualModules nullImports nullExportsenvModuleSourceSpanenvModuleImportsenvModuleExportsprimEnv exportTypeexportTypeClass exportValue getExportscheckImportConflicts findImportsresolveImportsresolveModuleImport UsedImportsName IdentNameTyName DctorName TyClassName lintImportslintparseImportDeclaration'parseDeclarationparseLocalDeclaration parseModuleparseModulesFromFiles parseModules parseValue parseBinderparseBinderNoParens parseGuard ForeignJSparseForeignModulesFromFilesUnknown CheckStatecheckEnv checkNextType checkNextKindcheckNextSkolemcheckNextSkolemScopecheckCurrentModulecheckSubstitution Substitution substType substKindemptySubstitutionemptyCheckState bindNames bindTypeswithScopedTypeVarswithTypeClassDictionariesgetTypeClassDictionarieslookupTypeClassDictionariesbindLocalVariablesbindLocalTypeVariablesmakeBindingGroupVisiblewithBindingGroupVisiblepreservingNameslookupVariable getVisibilitycheckVisibilitylookupTypeVariablegetEnvputEnv modifyEnvrunCheck runCheck' guardWith liftUnifyliftUnifyWarningskindOfkindOfWithScopedVarskindsOf kindsOfAllreplaceAllTypeSynonymscreateBindingGroupsModulecollapseBindingGroupsModulecreateBindingGroupscollapseBindingGroupsdesugarCasesModule desugarCasesdesugarTypeClassestypeClassMemberNamesuperClassDictionaryNamesmoduleToCoreFnrenameInModules moduleToJsdesugarDoModuledesugarObjectConstructors rebracketremoveSignedLiteralsdesugarOperatorSectionsderiveInstancesdesugarTypeDeclarationsModulefindExportableresolveExportsdesugarImportsWithEnvdesugarcheckDuplicateLabelsnewSkolemConstantintroduceSkolemScopenewSkolemScope skolemizeskolemizeTypesInValueskolemEscapeCheck freshType solveTypesubstituteType unifyTypes unifyRows unifiesWithreplaceVarWithUnknownreplaceTypeWildcards varIfUnknownentailssubsumestypesOftypeCheckModuleunMake RebuildPolicy RebuildNever RebuildAlwaysExterns MakeActionsgetInputTimestampgetOutputTimestamp readExternscodegenprogressProgressMessageCompilingModulerenderProgressMessagemakerunMakebuildMakeActionsversion RenderedCodeContainingModule ThisModule OtherModuleRenderedCodeElementSyntaxCtorKeywordSpaceasRenderedCodeElementasContainingModulemaybeToContainingModulecontainingModuleToMaybefromContainingModuleasRenderedCode outputWithspsyntaxidentctorkindkeyword keywordForall keywordDatakeywordNewtype keywordType keywordClasskeywordInstance keywordWhere keywordFixityRenderTypeOptionsprettyPrintObjects currentModule renderRow renderKindrenderTypeAtom renderTypedefaultRenderTypeOptionsrenderTypeWithOptions InPackageLocalFromDepBookmark PackageErrorCompilerTooOldErrorInPackageMetaInvalidVersionInvalidDeclarationTypeInvalidChildDeclarationType InvalidFixity InvalidKindInvalidDataDeclType GithubRepo runGithubRepo GithubUser runGithubUserChildDeclarationInfo ChildInstanceChildDataConstructorChildTypeClassMemberChildDeclaration cdeclTitle cdeclCommentscdeclSourceSpan cdeclInfoDeclarationInfoAliasDeclaration declTitle declCommentsdeclSourceSpan declChildren declFixitydeclInfomodName modCommentsmodDeclarations modReExportsVerifiedPackageUploadedPackage NotYetKnownPackagepkgMeta pkgVersion pkgVersionTag pkgModules pkgBookmarkspkgResolvedDependencies pkgGithub pkgUploaderpkgCompilerVersion verifyPackage packageNamedeclInfoToString isTypeClassisValueisTypeisAliasfilterChildrenchildDeclInfoToStringisTypeClassMemberisDataConstructor takeLocal takeLocals ignorePackageparseUploadedPackageparseVerifiedPackage asPackageasUploadedPackage asNotYetKnownasVerifiedPackagedisplayPackageError asGithubUser asVersion parseVersion'asModule asDeclaration asReExport asInPackageasFixityparseAssociativityasAssociativityasDeclarationInfoasTypeArgumentsasKindasTypeasDataDeclTypeasChildDeclarationasChildDeclarationInfo asSourcePos asConstraintasQualifiedProperNameasQualifiedIdent asBookmarks asBookmarkasResolvedDependenciesasGithub asSourceSpanassocListToJSON$fToJSONInPackage$fToJSONGithubRepo$fToJSONGithubUser$fToJSONChildDeclarationInfo$fToJSONDeclarationInfo$fToJSONChildDeclaration$fToJSONDeclaration$fToJSONModule$fToJSONNotYetKnown$fToJSONPackage$fFromJSONGithubUser$fFromJSONPackage$fFromJSONNotYetKnown$fFunctorInPackagerenderDeclarationrenderDeclarationWithOptionsrenderChildDeclaration!renderChildDeclarationWithOptionsrenderConstraintrenderConstraintWithOptionsrenderConstraintsrenderConstraintsWithOptions notQualifiedtypeApp toTypeVarconvertSingleModulecollectBookmarksupdateReExportsconvertModulesInPackageconvertModulesparseAndDesugarDocsrenderModulesAsMarkdownmodulesAsMarkdownrunDocs OtherError ProcessFailedIOExceptionThrown JSONSourceFromFile FromBowerList InternalError JSONErrorRepositoryFieldErrorRepositoryFieldMissingBadRepositoryType NotOnGithub UserErrorBowerJSONNotFoundBowerExecutableNotFoundCouldntDecodeBowerJSONTagMustBeCheckedOutAmbiguousVersionsBadRepositoryFieldMissingDependencies CompileErrorDirtyWorkingTreePackageWarningNoResolvedVersionUndeclaredDependencyUnacceptableVersionDirtyWorkingTree_Warn printError renderErrorrenderWarnings printWarningsPrepareMPublishOptionspublishGetVersionpublishWorkingTreeDirtydefaultPublishOptionspreparePackage runPrepareMwarn userError otherErrorpreparePackage'getModulesAndBookmarksgetGitWorkingTreeStatuscheckCleanWorkingTreegetVersionFromGitTag getBowerInfogetResolvedDependenciescatchIObindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName ModuleElement ExportTypeKeynodecheckImportPathwithDepstoModulecompile isModuleEmptycodeGenRequireMember ExportsListOther RegularExportForeignReexportshowModuleTypetco'langDef tokenParserLParenRParenLBraceRBraceLSquareRSquareIndentLArrowRArrow LFatArrow RFatArrowColon DoubleColonEqualsPipeTickDotCommaSemiAt UnderscoreLNameUName QualifierSymbolNumberprettyPrintToken parseTokens whitespace parseCommentparsePositionedToken parseTokenvalidModuleName$fShowPositionedToken parseStar parseBang parseFunction parseObjectparseTypeWildcardparseTypeVariableparseTypeConstructor parseForAllparseConstrainedType parseAnyTypeparseNameAndTypeparseRowEndingparseRowfilterDataConstructorsfilterInstancestypeInstanceConstituentsisDctorExportedbaseGHC.BasemagicDo'inlineST shouldInlineopAddopMulopEqopNotEq opLessThanopLessThanOrEq opGreaterThanopGreaterThanOrEqopAppendopSubopNegateopDivopModopConjopDisjopNot optimize'untilFixedPoint typeLiteralsmatchRowfunKindconstraintsAsBoxconstraintAsBoxappliedFunctionkindedinsertPlaceholders constrained matchTypeAtom matchTypeforall_prettyPrintJS1prettyPrintJS'literalsstring conditionalaccessorindexerlamapptypeOf instanceOfunary'unarynegateOperatorbinaryprettyStatements$fFromJSONExternsImport$fFromJSONExternsFixity$fFromJSONExternsDeclaration$fFromJSONExternsFilelistprettyPrintValueAtomellipsisprettyPrintObjectprettyPrintDeclarationprettyPrintCaseAlternativeprettyPrintDoNotationElement usedModulesRedundancyError qualifyNamegetConstructors initialize genericMergemissingCasesSinglemissingCasesMultipleisExhaustiveGuard otherwise missingCasescheckExhaustivecheckExhaustiveDecls IncompletemissingAlternative primExports addExportthrowConflictError resolveImport ImportDef getIdentName getTypeName getClassNamelintImportDecl findUsedRefs matchNameextractQualName matchDctor runDeclRef getTypeRefaddModuleLocErrorwithSourceSpanparseInfixExprindexersAndAccessors kindedIdentparseDataDeclarationparseTypeDeclarationparseTypeSynonymDeclarationparseValueDeclarationparseExternDeclaration parseFixityparseFixityDeclarationparseImportDeclarationparseDeclarationRefparseTypeClassDeclarationparseConstraintparseInstanceDeclarationparseTypeInstanceDeclaration parseDerivingInstanceDeclaration positionedtoPositionedError toSourcePosbooleanLiteralparseNumericLiteralparseCharLiteralparseStringLiteralparseBooleanLiteralparseArrayLiteralparseObjectLiteralparseIdentifierAndValueparseAbsparseVarparseConstructor parseCaseparseCaseAlternativeparseIfThenElseparseLetparseValueAtomparseOperatorSectionparsePropertyUpdate parseAccessorparseDoparseDoNotationLetparseDoNotationBindparseDoNotationElementparseObjectGetterparseUpdaterBodyparseObjectUpdaterWildcardparseStringBinderparseCharBinderparseBooleanBinderparseNumberBinderparseNullaryConstructorBinderparseConstructorBinderparseObjectBinderparseArrayBinderparseVarOrNamedBinderparseNullBinderparseIdentifierAndBinderfindModuleName freshKind solveKindsubstituteKind occursCheck unifyKinds solveTypes starIfUnknowninfer freshKindVarinfer'replaceAllTypeSynonyms'toBindingGroupcollapseBindingGroupsForValue usedIdentsusedImmediateIdents usedTypeNamesgetIdenttoDataBindingGroup isTypeSynonym fromValueDecl validateCasesisLeft desugarAbs inSameGrouptoDeclstoTuplemakeCaseDeclarationDesugar MemberMap desugarModule desugarDeclmemberToNameAndTypetypeClassDictionaryDeclaration#typeClassMemberToDictionaryAccessor!typeInstanceDictionaryDeclarationfindQualModulesimportToCoreFnexternToCoreFnexportToCoreFnmkTypeClassConstructor properToIdent RenameState rsBoundNames rsUsedNames runRenamenewScope updateScope lookupIdentfindDeclIdents renameInDecl renameInValuerenameInLiteralrenameInCaseAlternativerenameInBinderRename initState desugarDoChainrebracketModule removeParensexternsFixitiescollectFixitiesensureNoDuplicatescustomOperatorTablematchOperatorstoAssocparseOp parseTicksmatchOpderiveInstanceunwrapTypeConstructor dataGeneric dataMaybe typesProxy deriveGeneric findTypeDeclmkSpineFunctionmkSignatureFunctionmkFromSpineFunction objectTypelamNulllamCaseliftApplicativemkVarMnmkVar mkPrelVarmkGenVar decomposeRec filterModuleelaborateExportsrenameInModuleupdateExportRefsGHC.NumunknownsInTypetypeHeadsAreEqualpairwise subsumes'isTyped overTypesreplaceTypeClassDictionaries checkTypeKindinstantiatePolyTypeWithUnknowns inferBinderbinderRequiresMonotypeinstantiateForBinders checkBinderscheckcheck'checkPropertiescheckFunctionApplicationcheckFunctionApplication'meetensureNoDuplicateProperties UntypedDataTypeDatatypeDictionaryForBindingGroupcheckTypedBindingGroupElementtypeForBindingGroupElementinferLetBindingcheckTypeSynonyms typeCheckAll addDataTypeaddDataConstructoraddTypeSynonymvalueIsNotDefinedaddValue addTypeClassaddTypeClassDictionariescheckDuplicateTypeArgumentscheckTypeClassInstance importPrimmakeIOtraverseEither$fMonadBaseControlIOMake$fMonadBaseIOMakeMaybeRCunRC$fToJSONRenderedCode$fToJSONContainingModule$fToJSONRenderedCodeElement renderHead renderLabel renderTaildePrimconvertconvertForAllspreprocessTypepure ApplicativeDeclarationAugmentIntermediateDeclarationaugmentDeclarationsaddDefaultFixity mkDeclaration AugmentChild AugmentFixitygetDeclarationTitlebasicDeclarationconvertDeclarationconvertCommentscollectBookmarks' TypeClassEnvenvUnhandledMembers envValuesenvTypeClasses getReExportscollectDeclarations findImportlookupTypeDeclarationlookupModuleDeclarations handleEnvfilterTypeClassMemberstypeClassConstraintForlookupValueDeclarationlookupTypeClassDeclarationhandleTypeClassMembersvalsAndMembersToEnvtypeClassesToEnvsplitMapfilterExportedChildrenallDeclarations|>internalErrorInModule$fMonoidTypeClassEnv convertSortedFileInfo parseFilesdesugarWithBookmarks throwLeftfileInfoToString parseFileparseAsgetDepsModuleNames addPackageFirstNotFirstmoduleAsMarkdowndeclAsMarkdown codeToStringfixityAsMarkdown childToStringtell' headerLevel fencedBlockticksCollectedWarningsnoResolvedVersionsundeclaredDependenciesunacceptableVersionsdirtyWorkingTreedisplayUserErrordisplayRepositoryErrordisplayInternalErrordisplayJSONSourcedisplayOtherErrorcollectWarningswarnNoResolvedVersionswarnUndeclaredDependencieswarnUnacceptableVersionswarnDirtyWorkingTree$fMonoidCollectedWarningsMissing NoResolution ResolvedOtherResolvedVersionasToplevelDependencies isPureScriptDependencyStatus TreeStatusCleanDirty unPrepareM catchLeft extractGithub readProcess'findBowerExecutableasDependencyStatuswarnUndeclared handleDepstryExtractVersiongetInputAndDepsFileswithPackageNamegetPackageName$fMonadIOPrepareM