!$w      !"#$%&'()*+,-./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 { | } ~                                                  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvNone79Oz brickAn attribute map which maps  values to w values.brick9An attribute name. Attribute names are hierarchical; use x (y) to assemble them. Hierarchy in an attribute name is used to represent increasing levels of specificity in referring to the attribute you want to use for a visual element, with names to the left being general and names to the right being more specific. For example: J"window" <> "border" "window" <> "title" "header" <> "clock" <> "seconds" brick'Create an attribute name from a string.brick(Get the components of an attribute name.brickCreate an attribute map.brickHCreate an attribute map in which all lookups map to the same attribute.brickGiven an attribute and a map, merge the attribute with the map's default attribute. If the map is forcing all lookups to a specific attribute, the forced attribute is returned without merging it with the one specified here. Otherwise the attribute given here is merged with the attribute map's default attribute in that any aspect of the specified attribute that is not provided falls back to the map default. For example, 1mergeWithDefault (fg blue) $ attrMap (bg red) [] returns blue `on` red brickLook up the specified attribute name in the map. Map lookups proceed as follows. If the attribute map is forcing all lookups to a specific attribute, that attribute is returned. If the attribute name is empty, the map's default attribute is returned. If the attribute name is non-empty, very subsequence of names from the specified name are used to perform a lookup, and the results are combined as in H, with more specific results taking precedence over less specific ones. For example: attrMapLookup ("foo" <> "bar") (attrMap a []) == a attrMapLookup ("foo" <> "bar") (attrMap (bg blue) [("foo" <> "bar", fg red)]) == red `on` blue attrMapLookup ("foo" <> "bar") (attrMap (bg blue) [("foo" <> "bar", red on cyan)]) == red `on` cyan attrMapLookup ("foo" <> "bar") (attrMap (bg blue) [("foo" <> "bar", fg red), ("foo", bg cyan)]) == red `on` cyan attrMapLookup ("foo" <> "bar") (attrMap (bg blue) [("foo", fg red)]) == red `on` blue brick4Set the default attribute value in an attribute map. brick4Get the default attribute value in an attribute map. brick7Insert a set of attribute mappings to an attribute map. brick.Update an attribute map such that a lookup of ontoName+ returns the attribute value specified by fromName. This is useful for composite widgets with specific attribute names mapping those names to the sub-widget's expected name when calling that sub-widget's rendering function. See the ProgressBarDemo for an example usage, and  overrideAttr for an alternate syntax. brickXMap several attributes to return the value associated with an alternate name. Applies   across a list of mappings.brickThe map's default attribute to be returned when a name lookup fails, and the attribute that will be merged with successful lookups.brickThe map's initial contents.    SafeVbrickBChan9 is an abstract type representing a bounded FIFO channel.brick%Builds and returns a new instance of BChan.brickWrites a value to a BChan ; blocks if the channel is full.brickReads the next value from the BChan; blocks if necessary.brick!Reads the next value from either BChan, prioritizing the first BChan; blocks if necessary.brick/maximum number of elements the channel can holdSafe[Hbrick_A template haskell function to build lenses for a record type. This function differs from the i function in that it does not require the record fields to be prefixed with underscores and it adds an L= suffix to lens names to make it clear that they are lenses.None479@A]9brickA terminal screen location.!brick (Column, Row)zbrickThe origin (upper-left corner). !"#$%&'(z)*+,None79P-brickA theme provides a set of default attribute mappings, a default attribute, and a set of customizations for the default mapping and default attribute. The idea here is that the application will always need to provide a complete specification of its attribute mapping, but if the user wants to customize any aspect of that default mapping, it can be contained here and then built into an  (see U). We keep the defaults separate from customizations to permit users to serialize themes and their customizations to, say, disk files./brickThe default attribute to use.0brick%The default attribute mapping to use.1brick0Customization for the theme's default attribute.2brickCustomizations for individual entries of the default mapping. Note that this will only affect entries in the default mapping; any attributes named here that are not present in the default mapping will not be considered.3brick'Documentation for a theme's attributes.5brickzThe per-attribute documentation for a theme so e.g. documentation for theme customization can be generated mechanically.6brickSAn attribute customization can specify which aspects of an attribute to customize.8brick"The customized foreground, if any.9brick"The customized background, if any.:brickThe customized style, if any.TbrickvCreate a new theme with the specified default attribute and attribute mapping. The theme will have no customizations.Ubrick Build an  from a -3. This applies all customizations in the returned .{brick|This function is lossy in the sense that we only internally support 240 colors but the #RRGGBB format supports 16^3 colors.VbrickApply customizations using a custom lookup function. Customizations are obtained for each attribute name in the theme. Any customizations already set are lost.WbrickLoad an INI file containing theme customizations. Use the specified theme to determine which customizations to load. Return the specified theme with customizations set. See the module documentation for the theme file format.XbrickSave an INI file containing theme customizations. Use the specified theme to determine which customizations to save. See the module documentation for the theme file format.YbrickSave an INI file containing all attributes from the specified theme. Customized attributes are saved, but if an attribute is not customized, its default is saved instead. The file can later be re-loaded as a customization file.Vbrick=An optional customization for the theme's default attribute.brickBA function to obtain a customization for the specified attribute.brickThe theme to customize.-./0123456789:LMNOPQRSTUVWXY6789:MLN-./012TQRPO345SUVWXYSafe79lZbrickYA border style for use in any widget that needs to render borders in a consistent style.\brickTop-left corner character]brickTop-right corner character^brickBottom-right corner character_brickBottom-left corner character`brickFull intersection (cross)abrick<Left side of a horizontal border intersecting a vertical onebbrick=Right side of a horizontal border intersecting a vertical onecbrick6Top of a vertical border intersecting a horizontal onedbrick9Bottom of a vertical border intersecting a horizontal oneebrickHorizontal border characterfbrickVertical border characterhbrick=Make a border style using the specified character everywhere.ibrick6An ASCII border style which will work in any terminal.jbrickDA unicode border style with real corner and intersection characters.kbrick*A unicode border style in a bold typeface.lbrick,A unicode border style with rounded corners.Z[\]^_`abcdefghijklZ[\]^_`abcdefhijklgSafe479 rbrickRun n a represents n copies of the value a.vbrickSemantically, v and | are identical; but vZ is more efficient when large sequences of contiguous keys are mapped to the same value.wbrick This function is unsafe because vs that compare equal may split their runs into different chunks; consumers must promise that they do not treat run boundaries specially.}brickGiven a range of keys (as specified by a starting key and a length for consistency with other functions in this module), restrict the map to keys in that range. restrict k r m is equivalent to ,intersectionWith const m (insert k r empty) but potentially more efficient.brick splitLE n m produces a tuple (le, gt) where le has all the associations of m where the keys are <= n and gt has all the associations of m where the keys are > n.brick6Increment all keys by the given amount. This is like }/, but restricted to partially-applied addition.brick This function is unsafe because vs that compare equal may split their runs into different chunks; consumers must promise that they do not treat run boundaries specially.bricklThis function is unsafe because it assumes there is no overlap between its arguments. That is, in the call unsafeUnion a b%, the caller must guarantee that if lookup k a = Just v then lookup k b = Nothing and vice versa.brick Zippy: '( *g)' combines values at equal keys, discarding any values whose key is in only one of its two arguments.rstuvwxyz{|}~vrstuxyz{|}~wNone479@A{brickA  BorderMap a is like a Map Location a., except that there is a rectangle, and only 5s on the border of this rectangle are retained. The  can be queried for the position and size of the rectangle. There are also efficient bulk query and bulk update operations for adjacent positions on the border.~brickInternal use only.brickqGiven a rectangle (specified as the coordinates of the top, left, bottom, and right sides), initialize an empty .brick An empty " that only tracks the point (0,0).brickA R that tracks only the given the point (and initially maps it to the given value).brickKThe positions of the edges of the rectangle whose border is retained in a . For example, if coordinates m = e$, then the top border contains the  s on row eTop e and between columns eLeft e to eRight e inclusive.brickWA complementary way to query the edges of the rectangle whose border is retained in a . For example, if  bounds m = b , then a  'Location'\'s column must be between  fst (eTop b) and  snd (eTop b) to be retained. See also 6, which is in most cases a more natural border query.brick\Maps giving the values along each edge. Corner values are replicated in all relevant edges.brick4Bulk insertion of horizontally-adjacent values. The ! gives the start point, and the r+ extends in the "larger columns" direction.brick2Bulk insertion of vertically-adjacent values. The ! gives the start point, and the r( extends in the "larger rows" direction.brick,Insert a single value at the given location.brick'Look up all values on a given row. The v" returned maps columns to values.brick*Look up all values on a given column. The v returned maps rows to values.brick1Bulk lookup of horizontally-adjacent values. The $ gives the starting point, and the r1 extends in the "larger columns" direction. The v! returned maps columns to values.brick/Bulk lookup of vertically-adjacent values. The $ gives the starting point, and the r. extends in the "larger rows" direction. The v returned maps rows to values.brickLook up a single position.brick(Set the rectangle being tracked by this B, throwing away any values that do not lie on this new rectangle.brick0Ensure that the rectangle being tracked by this ( extends no farther than the given one.brick0Ensure that the rectangle being tracked by this + extends at least as far as the given one.brickMove a  by adding the given  to all keys in the map.brickAssumes the two Zs are tracking the same rectangles, but have disjoint keys. This property is not checked."#$%&')*+,"#$%&',)+*None479@A/%brickA border character has four segments, one extending in each direction (horizontally and vertically) from the center of the character.brickQWould this segment be willing to be drawn if a neighbor wanted to connect to it?brick2Does this segment want to connect to its neighbor?brick,Should this segment be represented visually?brick@A cursor location. These are returned by the rendering process.brick The locationbrick3The name of the widget associated with the locationbrick7The class of types that behave like terminal locations.brickGet the column out of the valuebrickGet the row out of the valuebrickScrolling direction.brickUp/leftbrick Down/rightbrick@The type of actions to take upon completion of an event handler.brick:An extent of a named area: its size, location, and origin.brickYThe type of viewports that indicates the direction(s) in which a viewport is scrollable.brick6Viewports of this type are scrollable only vertically.brick8Viewports of this type are scrollable only horizontally.brickBViewports of this type are scrollable vertically and horizontally.brickNDescribes the state of a viewport as it appears as its most recent rendering.brick/The column offset of left side of the viewport.brick*The row offset of the top of the viewport.brickThe size of the viewport.brickkInformation about how to redraw a dynamic border character when it abuts another dynamic border character.brickThe fs to use when redrawing the border. Also used to filter connections: only dynamic borders with equal Zs will connect to each other.brickWhat wj to use to redraw the border character. Also used to filter connections: only dynamic borders with equal ws will connect to each other.brickThe type of result returned by a widget's rendering function. The result provides the image, cursor positions, and visibility requests that resulted from the rendering process.brick%The final rendered image for a widgetbrickIThe list of reported cursor positions for the application to choose frombrickfThe list of visibility requests made by widgets rendered while rendering this one (used by viewports)brick`Places where we may rewrite the edge of the image when placing this widget next to another one.brickThe rendering context. This tells widgets how to render: how much space they have in which to render, which attribute they should use to render, which bordering style should be used, and the attribute map available for rendering.brickThe type of events.brickThe event was a Vty event.brick#The event was an application event.brick>A mouse-down event on the specified region was received. The n8 value is the resource name of the clicked widget (see  clickable).brick<A mouse-up event on the specified region was received. The n8 value is the resource name of the clicked widget (see  clickable). !"#$%&'(z)*+,NonebrickGiven a minimum value and a maximum value, clamp a value to that range (values less than the minimum map to the minimum and values greater than the maximum map to the maximum). clamp 1 10 1110 clamp 1 10 22 clamp 5 10 15brick^Build an attribute from a foreground color and a background color. Intended to be used infix.brickaCreate an attribute from the specified foreground color (the background color is the "default").brickaCreate an attribute from the specified background color (the background color is the "default").brickAdd a  offset to the specified .brickThe minimum valuebrickThe maximum valuebrickThe value to clampbrickThe foreground colorbrickThe background colorNoneMSX1brickThe type of the rendering monad. This monad is used by the library's rendering routines to manage rendering state and communicate rendering parameters to widgets' rendering functions. brickThe type of widgets. brick&This widget's horizontal growth policy brick$This widget's vertical growth policy brick This widget's rendering functionbrickWidget size policies. These policies communicate how a widget uses space when being rendered. These policies influence rendering order and space allocation in the box layout algorithm for hBox and vBox.brickWidgets advertising this size policy should take up the same amount of space no matter how much they are given, i.e. their size depends on their contents alone rather than on the size of the rendering area.brickPWidgets advertising this size policy must take up all the space they are given.brickuThe monad in which event handlers run. Although it may be tempting to dig into the reader value yourself, just use  .brickThe type of padding.brick/Pad by the specified number of rows or columns.brick2Pad up to the number of available rows or columns.brickA convenience function for handling events intended for values that are targets of lenses in your application state. This function obtains the target value of the specified lens, invokes  handleEventV on it, and stores the resulting transformed value back in the state using the lens.brick"Get the current rendering context.&brick2The rendering context's current drawing attribute.'brickpGiven an attribute name, obtain the attribute for the attribute name by consulting the context's attribute map.brickThe state value.brick>The lens to use to extract and store the target of the event.brickThe event handler.brickThe event to handle.y !"#$%&'()*+,      !"#$%&'y      !(&! "#$%'"#$%&',)+*None7P*brickhAfter rendering the specified widget, crop its result image to the dimensions in the rendering context.)* None =?@AHPSVX,:brickThe process of rendering widgets in a box layout is exactly the same except for the dimension under consideration (width vs. height), in which case all of the same operations that consider one dimension in the layout algorithm need to be switched to consider the other. Because of this we fill a BoxRenderer with all of the functions needed to consider the "primary" dimension (e.g. vertical if the box layout is vertical) as well as the "secondary" dimension (e.g. horizontal if the box layout is vertical). Doing this permits us to have one implementation for box layout and parameterizing on the orientation of all of the operations.+brick6The class of types that store interface element names.,brick$Get the name of the specified value.-brickRThe class of text types that have widths measured in terminal columns. NEVER use r etc. to measure the length of a string if you need to compute how much screen space it will occupy; always use ../brick^When rendering the specified widget, use the specified border style for any border rendering.0brick~When rendering the specified widget, create borders that respond dynamically to their neighbors to form seamless connections.1brickWhen rendering the specified widget, use static borders. This may be marginally faster, but will introduce a small gap between neighboring orthogonal borders.0This is the default for backwards compatibility.2brickAfter the specified widget has been rendered, freeze its borders. A frozen border will not be affected by neighbors, nor will it affect neighbors. Compared to 1, 2K will not affect whether borders connect internally to a widget (whereas 1 prevents them from connecting). Frozen borders cannot be thawed.3brickThe empty widget.4brick+Add an offset to all cursor locations, visbility requests, and extents in the specified rendering result. This function is critical for maintaining correctness in the rendering results as they are processed successively by box layouts and other wrapping combinators, since calls to this function result in converting from widget-local coordinates to (ultimately) terminal-global ones so they can be used by other combinators. You should call this any time you render something and then translate it or otherwise offset it from its original origin.5brick`Render the specified widget and record its rendering extent using the specified name (see also  lookupExtent).6brick3Request mouse click events on the specified widget.brickTake a substring capable of fitting into the number of specified columns. This function takes character column widths into consideration.7brickMake a widget from a string, but wrap the words in the input's lines at the available width using the default wrapping settings. The input string should not contain escapes.Unlike ;, this is greedy horizontally.8brickMake a widget from a string, but wrap the words in the input's lines at the available width using the specified wrapping settings. The input string should not contain escapes.Unlike ;, this is greedy horizontally.9brickMake a widget from text, but wrap the words in the input's lines at the available width using the default wrapping settings. The input text should not contain escapes.Unlike <, this is greedy horizontally.:brickMake a widget from text, but wrap the words in the input's lines at the available width using the specified wrapping settings. The input text should not contain escapes.Unlike <, this is greedy horizontally.;brickBuild a widget from a W. Breaks newlines up and space-pads short lines out to the length of the longest line.3The input string must not contain tab characters. If it does, interface corruption will result since the terminal will likely render it as taking up more than a single column. The caller should replace tabs with the appropriate number of spaces as desired. The reinput string should not contain escapes.<brickBuild a widget from a  value. Behaves the same as ;) when the input contains multiple lines.1The input string must not contain tab characters. If it does, interface corruption will result since the terminal will likely render it as taking up more than a single column. The caller should replace tabs with the appropriate number of spaces as desired. The reinput text should not contain escapes.=brickHyperlink the given widget to the specified URL. Not all terminal emulators support this. In those that don't, this should have no discernible effect.>brickPad the specified widget on the left. If max padding is used, this grows greedily horizontally; otherwise it defers to the padded widget.?brickPad the specified widget on the right. If max padding is used, this grows greedily horizontally; otherwise it defers to the padded widget.@brickPad the specified widget on the top. If max padding is used, this grows greedily vertically; otherwise it defers to the padded widget.AbrickPad the specified widget on the bottom. If max padding is used, this grows greedily vertically; otherwise it defers to the padded widget.BbrickSPad a widget on the left and right. Defers to the padded widget for growth policy.CbrickSPad a widget on the top and bottom. Defers to the padded widget for growth policy.DbrickJPad a widget on all sides. Defers to the padded widget for growth policy.Ebrick_Fill all available space with the specified character. Grows both horizontally and vertically.FbrickVertical box layout: put the specified widgets one above the other in the specified order (uppermost first). Defers growth policies to the growth policies of the contained widgets (if any are greedy, so is the box).GbrickHorizontal box layout: put the specified widgets next to each other in the specified order (leftmost first). Defers growth policies to the growth policies of the contained widgets (if any are greedy, so is the box).brick>Render a series of widgets in a box layout in the order given. The growth policy of a box layout is the most unrestricted of the growth policies of the widgets it contains, so to determine the hSize and vSize of the box we just take the maximum (using the Ord instance for Size) of all of the widgets to be rendered in the box.Then the box layout algorithm proceeds as follows. We'll use the vertical case to concretely describe the algorithm, but the horizontal case can be envisioned just by exchanging all "vertical""horizontal" and "rows"%"columns", etc., in the description.,The growth policies of the child widgets determine the order in which they are rendered, i.e., the order in which space in the box is allocated to widgets as the algorithm proceeds. This is because order matters: if we render greedy widgets first, there will be no space left for non-greedy ones.#So we render all widgets with size  in the vertical dimension first. Each is rendered with as much room as the overall box has, but we assume that they will not be greedy and use it all. If they do, maybe it's because the terminal is small and there just isn't enough room to render everything.JThen the remaining height is distributed evenly amongst all remaining (greedy) widgets and they are rendered in sub-boxes that are as high as this even slice of rows and as wide as the box is permitted to be. We only do this step at all if rendering the non-greedy widgets left us any space, i.e., if there were any rows left. After rendering the non-greedy and then greedy widgets, their images are sorted so that they are stored in the order the original widgets were given. All cursor locations and visibility requests in each sub-widget are translated according to the position of the sub-widget in the box.All images are padded to be as wide as the widest sub-widget to prevent attribute over-runs. Without this step the attribute used by a sub-widget may continue on in an undesirable fashion until it hits something with a different attribute. To prevent this and to behave in the least surprising way, we pad the image on the right with whitespace using the context's current attribute.Finally, the padded images are concatenated together vertically and returned along with the translated cursor positions and visibility requests.brick%Given borders that should be placed next to each other (the first argument on the right or bottom, and the second argument on the left or top), compute new borders and the rewrites that should be done along the edges of the two images to keep the image in synch with the border information.KThe input borders are assumed to be disjoint. This property is not checked.brickfGiven a direction to concatenate borders in, and the border information itself (which list is assumed to be already shifted so that borders do not overlap and are strictly increasing in the primary direction), produce: a list of rewrites for the lo and hi directions of each border, respectively, and the borders describing the fully concatenated object.HbrickLimit the space available to the specified widget to the specified number of columns. This is important for constraining the horizontal growth of otherwise-greedy widgets. This is non-greedy horizontally and defers to the limited widget vertically.IbrickxLimit the space available to the specified widget to the specified percentage of available width, as a value between 0 and 100 inclusive. Values outside the valid range will be clamped to the range endpoints. This is important for constraining the horizontal growth of otherwise-greedy widgets. This is non-greedy horizontally and defers to the limited widget vertically.JbrickLimit the space available to the specified widget to the specified number of rows. This is important for constraining the vertical growth of otherwise-greedy widgets. This is non-greedy vertically and defers to the limited widget horizontally.KbrickwLimit the space available to the specified widget to the specified percentage of available height, as a value between 0 and 100 inclusive. Values outside the valid range will be clamped to the range endpoints. This is important for constraining the vertical growth of otherwise-greedy widgets. This is non-greedy vertically and defers to the limited widget horizontally.LbrickSet the rendering context height and width for this widget. This is useful for relaxing the rendering size constraints on e.g. layer widgets where cropping to the screen size is undesirable.MbrickWhen drawing the specified widget, set the current attribute used for drawing to the one with the specified name. Note that the widget may use further calls to M< to override this; if you really want to prevent that, use Q. Attributes used this way still get merged hierarchically and still fall back to the attribute map's default attribute. If you want to change the default attribute, use O.NbrickUpdate the attribute map while rendering the specified widget: set its new default attribute to the one that we get by looking up the specified attribute name in the map and then modifying it with the specified function.ObrickUpdate the attribute map while rendering the specified widget: set its new default attribute to the one that we get by looking up the specified attribute name in the map.PbrickaWhen rendering the specified widget, update the attribute map with the specified transformation.QbrickWhen rendering the specified widget, force all attribute lookups in the attribute map to use the value currently assigned to the specified attribute name.RbrickOverride the lookup of  targetName0 to return the attribute value associated with fromName0 when rendering the specified widget. See also  .Sbrick-Build a widget directly from a raw Vty image.TbrickrTranslate the specified widget by the specified offset amount. Defers to the translated widget for growth policy.UbrickzCrop the specified widget on the left by the specified number of columns. Defers to the cropped widget for growth policy.Vbrick{Crop the specified widget on the right by the specified number of columns. Defers to the cropped widget for growth policy.WbrickvCrop the specified widget on the top by the specified number of rows. Defers to the cropped widget for growth policy.XbrickyCrop the specified widget on the bottom by the specified number of rows. Defers to the cropped widget for growth policy.YbrickwWhen rendering the specified widget, also register a cursor positioning request using the specified name and location.ZbrickRender the specified widget. If the widget has an entry in the rendering cache using the specified name as the cache key, use the rendered version from the cache instead. If not, render the widget and update the cache. See also invalidateCacheEntry.[brickRender the specified widget in a named viewport with the specified type. This permits widgets to be scrolled without being scrolling-aware. To make the most use of viewports, the specified widget should use the ] combinator to make a "visibility request". This viewport combinator will then translate the resulting rendering to make the requested region visible. In addition, the  L monad provides primitives to scroll viewports created by this function if ] is not what you want.If a viewport receives more than one visibility request, then the visibility requests are merged with the inner visibility request taking preference. If a viewport receives more than one scrolling request from  ;, all are honored in the order in which they are received.\brickLGiven a name, obtain the viewport for that name by consulting the viewport map in the rendering monad. NOTE! Some care must be taken when calling this function, since it only returns useful values after the viewport in question has been rendered. If you call this function during rendering before a viewport has been rendered, you may get nothing or you may get a stale version of the viewport. This is because viewports are updated during rendering and the one you are interested in may not have been rendered yet. So if you want to use this, be sure you know what you are doing.]brick;Request that the specified widget be made visible when it is rendered inside a viewport. This permits widgets (whose sizes and positions cannot be known due to being embedded in arbitrary layouts) to make a request for a parent viewport to locate them and scroll enough to put them in view. This, together with [, is what makes the text editor and list widgets possible without making them deal with the details of scrolling state management.0This does nothing if not rendered in a viewport.^brick Similar to ]-, request that a region (with the specified  as its origin and J as its size) be made visible when it is rendered inside a viewport. The D is relative to the specified widget's upper-left corner of (0, 0).0This does nothing if not rendered in a viewport._brickHorizontal box layout: put the specified widgets next to each other in the specified order. Defers growth policies to the growth policies of both widgets. This operator is a binary version of G.`brickVertical box layout: put the specified widgets one above the other in the specified order. Defers growth policies to the growth policies of both widgets. This operator is a binary version of F.[brickKThe name of the viewport (must be unique and stable for reliable behavior)brickCThe type of viewport (indicates the permitted scrolling direction)brick4The widget to be rendered in the scrollable viewport_brickLeftbrickRight`brickTopbrickBottom7*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`7-.3S<9:;78E=>?@ABCD`_GFHIJKLONMQRP/012Y+,TUVWX56[]^\Z4* None5cbrick;The attribute of the completed portion of the progress bar.dbrick<The attribute of the incomplete portion of the progress bar.ebrickDraw a progress bar with the specified (optional) label and progress value. This fills available horizontal space and is one row high.ebrickJThe label. If specified, this is shown in the center of the progress bar.brick8The progress value. Should be between 0 and 1 inclusive.cdeecd None=?@ATX fbrick?Editor state. Editors support the following events by default: Ctrl-a: go to beginning of lineCtrl-e: go to end of line0Ctrl-d, Del: delete character at cursor position4Backspace: delete character prior to cursor position-Ctrl-k: delete all from cursor to end of line3Ctrl-u: delete all from cursor to beginning of lineArrow keys: move cursor4Enter: break the current line at the cursor positioniPaste: Bracketed Pastes from the terminal will be pasted, provided the incoming data is UTF-8-encoded.gbrickThe contents of the editorhbrickThe name of the editoribrickJValues that can be constructed by decoding bytestrings in UTF-8 encoding.jbrickYDecode a bytestring assumed to be text in UTF-8 encoding. If the decoding fails, return ". This must not raise exceptions.mbrickConstruct an editor over Text valuesnbrickConstruct an editor over  valuesobrickApply an editing operation to the editor's contents. Bear in mind that you should only apply zipper operations that operate on the current line; the editor will only ever render the first line of text.pbrickAThe attribute assigned to the editor when it does not have focus.qbrickAThe attribute assigned to the editor when it has focus. Extends p.rbrickGet the contents of the editor.sbrickTurn an editor state value into a widget. This uses the editor's name for its scrollable viewport handle and the name is also used to report mouse events.mbrick"The editor's name (must be unique)brick0The limit on the number of lines in the editor ( means no limit)brickThe initial contentnbrick"The editor's name (must be unique)brick0The limit on the number of lines in the editor ( means no limit)brickThe initial contentobrickThe  editing transformation to applysbrickThe content drawing functionbrick\Whether the editor has focus. It will report a cursor position if and only if it has focus.brick The editor.fghijklmnopqrsfghnmrlokspqij Noner xbrickSCenter the specified widget horizontally. Consumes all available horizontal space.ybrick-Center the specified widget horizontally using a Vty image translation. Consumes all available horizontal space. Unlike hCenter, this does not fill the surrounding space so it is suitable for use as a layer. Layers underneath this widget will be visible in regions surrounding the centered widget.zbrickCenter the specified widget horizontally. Consumes all available horizontal space. Uses the specified character to fill in the space to either side of the centered widget (defaults to space).{brick9Center a widget vertically. Consumes all vertical space.|brick)Center the specified widget vertically using a Vty image translation. Consumes all available vertical space. Unlike vCenter, this does not fill the surrounding space so it is suitable for use as a layer. Layers underneath this widget will be visible in regions surrounding the centered widget.}brickCenter a widget vertically. Consumes all vertical space. Uses the specified character to fill in the space above and below the centered widget (defaults to space).~brickhCenter a widget both vertically and horizontally. Consumes all available vertical and horizontal space.brickCenter a widget both vertically and horizontally. Consumes all available vertical and horizontal space. Uses the specified character to fill in the space around the centered widget (defaults to space).brickOCenter a widget both vertically and horizontally using a Vty image translation. Consumes all available vertical and horizontal space. Unlike center, this does not fill in the surrounding space with a character so it is usable as a layer. Any widget underneath this one will be visible in the region surrounding the centered widget.brickJCenter the widget horizontally and vertically about the specified origin. xyz{|}~ xzy{}|~None brick$The top-level border attribute name.brickGDraw the specified border element using the active border style using .xDoes not participate in dynamic borders (due to the difficulty of introspecting on the first argument); consider using  instead.brick)Put a border around the specified widget.brick|Put a border around the specified widget with the specified label widget placed in the middle of the top horizontal border.Note that a border will wrap its child widget as tightly as possible, which means that if the child widget is narrower than the label widget, the label widget will be truncated. If you want to avoid this behavior, add a E or other space-filling wrapper to the bordered widget so that it takes up enough room to make the border horizontally able to avoid truncating the label.brick1A horizontal border. Fills all horizontal space.brickaA horizontal border with a label placed in the center of the border. Fills all horizontal space.brick-A vertical border. Fills all vertical space.brick Initialize a  . It will be n and ~ing in the given directions to begin with, and accept join offers from all directions. We consult the context to choose the  and .mThis is likely to be useful only for custom widgets that need more complicated dynamic border behavior than , , or  offer.brick Replace the  'Result'\'_s dynamic borders with the given one, provided the context says to use dynamic borders at all.brickxA single-character dynamic border that will react to neighboring borders, initially connecting in the given directions.brickThe label widgetbrick!The widget to put a border aroundbrickThe label widgetNone brickDialogs present a window with a title (optional), a body, and buttons (optional). Dialog buttons are labeled with strings and map to values of type a, which you choose.GDialogs handle the following events by default with handleDialogEvent:*Tab or Right Arrow: select the next button3Shift-tab or Left Arrow: select the previous buttonbrickThe dialog titlebrick#The dialog button labels and valuesbrick3The currently selected dialog button index (if any)brickThe maximum width of the dialogbrickCreate a dialog.brick#The default attribute of the dialogbrick,The default attribute for all dialog buttonsbrick6The attribute for the selected dialog button (extends )brickRender a dialog with the specified body widget. This renders the dialog as a layer, which makes this suitable as a top-level layer in your rendering function to be rendered on top of the rest of your interface.brickObtain the value associated with the dialog's currently-selected button, if any. This function is probably what you want when someone presses Enter in a dialog.brickThe dialog titlebrick_The currently-selected button index (starting at zero) and the button labels and values to usebrickThe maximum width of the dialogNoneZ brick\A focus ring containing a sequence of resource names to focus and a currently-focused name.brick7Construct a focus ring from the list of resource names.brick,Advance focus to the next value in the ring.brick0Advance focus to the previous value in the ring.brick~This function is a convenience function to look up a widget state value's resource name in a focus ring and set its focus setting according to the focus ring's state. This function determines whether a given widget state value is the focus of the ring and passes the resulting boolean to a rendering function, along with the state value (a), to produce whatever comes next (b).^Focus-aware widgets have rendering functions that should be usable with this combinator; see   and  !.brickUGet the currently-focused resource name from the ring. If the ring is emtpy, return .brick}Set the currently-focused resource name in the ring, provided the name is in the ring. Otherwise return the ring unmodified.brickModify the internal circular list structure of a focus ring directly. This function permits modification of the circular list using the rich Data.CircularList API.brick5Cursor selection convenience function for use as an  " value.brick3The focus ring to use as the source of focus state.brick2A function that takes a value and its focus state.brick6The wiget state value that we need to check for focus.brickThe rest of the computation.brickGThe function used to get the focus ring out of your application state.brickYour application state.brick'The list of available cursor positions.brickVThe cursor position, if any, that matches the resource name currently focused by the .   NoneX&&brickHA viewport scrolling handle for managing the scroll state of viewports.brickDThe name of the viewport to be controlled by this scrolling handle.brickIScroll the viewport horizontally by one page in the specified direction.brick{Scroll the viewport horizontally by the specified number of rows or columns depending on the orientation of the viewport.brick6Scroll horizontally to the beginning of the viewport.brick/Scroll horizontally to the end of the viewport.brickGScroll the viewport vertically by one page in the specified direction.brickyScroll the viewport vertically by the specified number of rows or columns depending on the orientation of the viewport.brick3Scroll vertically to the beginning of the viewport.brick-Scroll vertically to the end of the viewport.brick'Set the top row offset of the viewport.brick+Set the left column offset of the viewport.brickThe library application abstraction. Your application's operations are represented here and passed to one of the various main functions in this module. An application is in terms of an application state type s, an application event type e, and a resource name type n. In the simplest case e^ is unused (left polymorphic or set to '()'), but you may define your own event type and use  to provide custom events. The state type is the type of application state to be provided by you and iteratively modified by event handlers. The resource name type is the type of names you can assign to rendering resources such as viewports and cursor locations.bricknThis function turns your application state into a list of widget layers. The layers are listed topmost first.brickThis function chooses which of the zero or more cursor locations reported by the rendering process should be selected as the one to use to place the cursor. If this returns , no cursor is placed. The rationale here is that many widgets may request a cursor placement but your application state is what you probably want to use to decide which one wins.brickThis function takes the current application state and an event and returns an action to be taken and a corresponding transformed application state. Possible options are , , and .brickThis function gets called once just prior to the first drawing of your application. Here is where you can make initial scrolling requests, for example.brick7The attribute map that should be used during rendering.brickxThe default main entry point which takes an application and an initial state and returns the final state returned by a  operation.brickA simple main entry point which takes a widget and renders it. This event loop terminates when the user presses any key, but terminal resize events cause redraws.brickKA simple application with reasonable defaults to be overridden as desired:Draws only the specified widget%Quits on any event other than resizesHas no start event handlerProvides no attribute mapNever shows any cursorsbrickAn event-handling function which continues execution of the event loop only when resize events occur; all other types of events trigger a halt. This is a convenience function useful as an * value for simple applications using the = type that do not need to get more sophisticated user input.brickThe custom event loop entry point to use when the simpler ones don't permit enough control. Returns the final application state after the application halts.brickLike , except the last J handle used by the application is returned without being shut down with (. This allows the caller to re-use the ? handle for something else, such as another Brick application.brickoGiven a viewport name, get the viewport's size and offset information from the most recent rendering. Returns y if no such state could be found, either because the name was invalid or because no rendering has occurred (e.g. in an  handler).brickRDid the specified mouse coordinates (column, row) intersect the specified extent?brickSGiven a resource name, get the most recent rendering extent for the name (if any).brickWGiven a mouse click location, return the extents intersected by the click. The returned extents are sorted such that the first extent in the list is the most specific extent and the last extent is the most generic (top-level). So if two extents A and B both intersected the mouse click but A contains B, then they would be returned [B, A].brick$Get the Vty handle currently in use.brickGInvalidate the rendering cache entry with the specified resource name.brick&Invalidate the entire rendering cache.brickwIgnore all requested cursor positions returned by the rendering process. This is a convenience function useful as an E value when a simple application has no need to position the cursor.brickwAlways show the first cursor, if any, returned by the rendering process. This is a convenience function useful as an X value when a simple program has zero or more widgets that advertise a cursor position.brick_Show the cursor with the specified resource name, if such a cursor location has been reported.brickCBuild a viewport scroller for the viewport with the specified name.brickFContinue running the event loop with the specified application state.brickYHalt the event loop and return the specified application state as the final state value.brickSuspend the event loop, save the terminal state, and run the specified action. When it returns an application state value, restore the terminal state, empty the rendering cache, redraw the application from the new state, and resume the event loop.brickThe application.brickThe initial application state.brickThe widget to draw.brickThe initial Vty handle to use.brickAn IO action to build a Vty handle. This is used to build a Vty handle whenever the event loop needs to reinitialize the terminal, e.g. on resume after suspension.brickAn event channel for sending custom events to the event loop (you write to this channel, the event loop reads from it). Provide - if you don't plan on sending custom events.brickThe application.brickThe initial application state.brickThe initial Vty handle to use.brickAn IO action to build a Vty handle. This is used to build a Vty handle whenever the event loop needs to reinitialize the terminal, e.g. on resume after suspension.brickAn event channel for sending custom events to the event loop (you write to this channel, the event loop reads from it). Provide - if you don't plan on sending custom events.brickThe application.brickThe initial application state.))))None 4567=?@AP\(brick#List state. Lists have a container t of element type ea that is the data stored by the list. Internally, Lists handle the following events by default:0Up/down arrow keys: move cursor of selected itemtPage up / page down keys: move cursor of selected item by one page at a time (based on the number of items shown)JHome/end keys: move cursor of selected item to beginning or end of listThe  type synonym fixes t to ; for compatibility with previous versions of this library.'For a container type to be usable with , it must have instances of  and 6. The following functions impose further constraints::  and : : : brick The list's sequence of elements.brick*The list's selected element index, if any.brickThe list's name.brick-The height of an individual item in the list.brickgOrdered container types where the order of elements can be reversed. Only required if you want to use .brickOrdered container types that can be split at a given index. An instance of this class is required for a container type to be usable with .brick(Split at the given index. Equivalent to (take n xs, drop n xs) and therefore total.brick#Slice the structure. Equivalent to (take n . drop i) xs and therefore total.#The default implementation applies i two times: first to drop elements leading up to the slice, and again to drop elements after the slice.brick An alias for  specialized to use a Vector as its container type.brick<Handle events for list cursor movement. Events handled are:Up (up arrow key)Down (down arrow key)Page Up (PgUp)Page Down (PgDown)Go to first element (Home)Go to last element (End)brickREnable list movement with the vi keys with a fallback handler if none match. Use   in place of N to add the vi keys bindings to the standard ones. Movements handled include:Up (k)Down (j)Page Up (Ctrl-b)Page Down (Ctrl-f)Half Page Up (Ctrl-u)Half Page Down (Ctrl-d)Go to first element (g)Go to last element (G)brick1The top-level attribute used for the entire list.brickiThe attribute used only for the currently-selected list item when the list does not have focus. Extends .brick_The attribute used only for the currently-selected list item when the list has focus. Extends .brick'Construct a list in terms of container t with element type e.brick8Render a list using the specified item drawing function.Evaluates the underlying container up to, and a bit beyond, the selected element. The exact amount depends on available height for drawing and +. At most, it will evaluate up to element  (i + h + 1) where i is the selected index and h is the available height.2Note that this function renders the list with the ) as the default attribute and then uses P as the default attribute for the selected item if the list is not focused or  otherwise. This is provided as a convenience so that the item rendering function doesn't have to be concerned with attributes, but if those attributes are undesirable for your purposes, Qe can always be used by the item rendering function to ensure that another attribute is used instead.brickLike N, except the render function is also provided with the index of each element.+Has the same evaluation characteristics as .brickDraws the list elements.Evaluates the underlying container up to, and a bit beyond, the selected element. The exact amount depends on available height for drawing and +. At most, it will evaluate up to element  (i + h + 1) where i is the selected index and h is the available height.brick5Insert an item into a list at the specified position.Complexity: the worse of  and y for the container type. listInsert for : O(n) listInsert for : O(log(min(i, length n - i))) brick8Remove an element from a list at the specified position.Applies  two times: first to split the structure at the given position, and again to remove the first element from the tail. Consider the asymptotics of 2 for the container type when using this function.Complexity: the worse of  and y for the container type. listRemove for : O(n) listRemove for : O(log(min(i, n - i))) brickReplace the contents of a list with a new set of elements and update the new selected index. If the list is empty, empty selection is used instead. Otherwise, if the specified selected index (via 2) is not in the list bounds, zero is used instead.Complexity: same as  for the container type.brick]Move the list selected index up by one. (Moves the cursor up, subtracts one from the index.)brick,Move the list selected index up by one page.brickZMove the list selected index down by one. (Moves the cursor down, adds one to the index.)brick.Move the list selected index down by one page.brickBMove the list selected index by some (fractional) number of pages.brickMove the list selected index.If the current selection is Just x, the selection is adjusted by the specified amount. The value is clamped to the extents of the list (i.e. the selection does not "wrap").If the current selection is NothingE (i.e. there is no selection) and the direction is positive, set to Just 0$ (first element), otherwise set to Just (length - 1) (last element).Complexity: same as  for the container type. listMoveBy for : O(1) listMoveBy for : O(log(min(i,n-i))) brickQSet the selected index for a list to the specified index, subject to validation.If pos >= 0S, indexes from the start of the list (which gets evaluated up to the target index)If pos < 04, indexes from the end of the list (which evalutes  of the list).Complexity: same as  for the container type. listMoveTo for : O(1) listMoveTo for : O(log(min(i,n-i))) brick)Split-based clamp that avoids evaluating E of the structure (unless the structure is already fully evaluated).brickSet the selected index for a list to the index of the first occurence of the specified element if it is in the list, or leave the list unmodified otherwise.O(n)5. Only evaluates as much of the container as needed.brickSet the selected index to the next element matching the predicate. If there is no selected element, the search starts at the beginning. If no matching element is found, leave the list unmodified.O(n)5. Only evaluates as much of the container as needed.brick)Return a list's selected element, if any.2Only evaluates as much of the container as needed.Complexity: same as  for the container type. listSelectedElement for : O(1) listSelectedElement for : O(log(min(i, n - i))) brick:Remove all elements from the list and clear the selection.O(1)brick[Reverse the list. The element selected before the reversal will again be the selected one.Complexity: same as  for the container type. listReverse for : O(n) listReverse for : O(n) brick^Apply a function to the selected element. If no element is selected the list is not modified.Complexity: same as $ for the container type (typically O(n)).brickO(log(min(i,n-i))) .brickO(1) .brickO(n) brickO(n) brick start index bricklength brick<Fallback event handler to use if none of the vi keys match.brickThe list name (must be unique)brickThe initial list contentsbrickHThe list item height in rows (all list item widgets must be this high).brick1Rendering function, True for the selected elementbrickWhether the list has focusbrickThe List to be renderedbrickrendered widgetbrickDRendering function, taking index, and True for the selected elementbrickWhether the list has focusbrickThe List to be renderedbrickrendered widgetbrick0The position at which to insert (0 <= i <= size)brickThe element to insertbrick;The position at which to remove an element (0 <= i < size)''NonePX`'1brick(The type of file entries in the browser.brickA regular disk file.brickA block device.brickA character device.brick A named pipe.brick A directory.brickA symbolic link.brickA Unix socket.brick.Information about a file entry in the browser.brick`The filename of this entry, without its path. This is not for display purposes; for that, use .brickeThe filename of this entry with out its path, sanitized of non-printable characters (replaced with ?%). This is for display purposes only.brick#The full path to this entry's file. brickvThe file status if it could be obtained, or the exception that was caught when attempting to read the file's status. brickFile status information. brick)The size, in bytes, of this entry's file. brick:The type of this entry's file, if it could be determined.brickTA file browser's state. Embed this in your application state and transform it with ., and the functions included in this module.brick9The exception status of the latest directory change. If , the latest directory change was successful and all entries were read. Otherwise, this contains the exception raised by the latest directory change in case the calling application needs to inspect or present the error to the user.brickyThe function that determines what kinds of entries are selectable with in the event handler. Note that if this returns  for an entry, an Enter or Spaceq keypress selects that entry rather than doing anything else; directory changes can only occur if this returns  for directories.UNote that this is a record field so it can be used to change the selection function. brickVMake a new file browser state. The provided resource name will be used to render the  viewport of the browser.uBy default, the browser will show all files and directories in its working directory. To change that behavior, see #.!brickA file entry selector that permits selection of all file entries except directories. Use this if you want users to be able to navigate directories in the browser. If you want users to be able to select only directories, use "."brickA file entry selector that permits selection of directories only. This prevents directory navigation and only supports directory selection.#brickvSet the filtering function used to determine which entries in the browser's current directory appear in the browser. = indicates no filtering, meaning all entries will be shown. * indicates a function that should return 1 for entries that should be permitted to appear.$brickSet the working directory of the file browser. This scans the new directory and repopulates the browser while maintaining any active search string and/or entry filtering. If the directory scan raises an  IOExceptionA, the exception is stored in the browser and is accessible with m. If no exception is raised, the exception field is cleared. Regardless of whether an exception is raised, ..7 is always presented as a valid option in the browser.%brickBuild a ) for the specified file and path. If an  IOException> is raised while attempting to get the file information, the  L field is populated with the exception. Otherwise it is populated with the   for the file.&brick^Get the file type for this file info entry. If the file type could not be obtained due to an  IOException , return .'brick.Get the working directory of the file browser.(brickReturns whether the file browser is in search mode, i.e., the mode in which user input affects the browser's active search string and displayed entries. This is used to aid in event dispatching in the calling program.)brickFGet the entries chosen by the user, if any. Entries are chosen by an Enter or Space8 keypress; if you want the entry under the cursor, use -.*brickModify the file browser's active search string. This causes the browser's displayed entries to change to those in its current directory that match the search string, if any. If a search string is provided, it is matched case-insensitively anywhere in file or directory names.+brickLGenerate a textual abbreviation of a file size, e.g. "10.2M" or "12 bytes".,brickBuild a list of file info entries for the specified directory. This function does not catch any exceptions raised by calling  makeAbsolute or  listDirectory, but it does catch exceptions on a per-file basis. Any exceptions caught when inspecting individual files are stored in the   field of each .LThe entries returned are all entries in the specified directory except for . and ..b. Directories are always given first. Entries are sorted in case-insensitive lexicographic order.qThis function is exported for those who want to implement their own file browser using the types in this module.-brick?Get the file information for the file under the cursor, if any..brickuHandle a Vty input event. Note that event handling can cause a directory change so the caller should be aware that z may need to be checked after handling an event in case an exception was triggered while scanning the working directory."Events handled regardless of mode:Enter, Space,: set the file browser's selected entry ()4) for use by the calling application, subject to .Ctrl-n: select the next entryCtrl-p: select the previous entry navigation keys#Events handled only in normal mode:/: enter search mode#Events handled only in search mode:Esc, Ctrl-C: cancel search mode Text input: update search string/brickRender a file browser. This renders a list of entries in the working directory, a cursor to select from among the entries, a header displaying the working directory, and a footer displaying information about the selected entry.NNote that if the most recent file browser operation produced an exception in , that exception is not rendered by this function. That exception needs to be rendered (if at all) by the calling application..The file browser is greedy in both dimensions.brickSSanitize a filename for terminal display, replacing non-printable characters with ?.0brick3The base attribute for all file browser attributes.1brickRThe attribute used for the current directory displayed at the top of the browser.2brickUThe attribute used for the entry information displayed at the bottom of the browser.3brick/The attribute used to render directory entries.4brick2The attribute used to render block device entries.5brick2The attribute used to render regular file entries.6brick6The attribute used to render character device entries.7brick0The attribute used to render named pipe entries.8brick3The attribute used to render symbolic link entries.9brick1The attribute used to render Unix socket entries.:brick<The attribute used for selected entries in the file browser.;brick A file type filter for use with #J. This filter permits entries whose file types are in the specified list.<brickA filter that matches any directory regardless of name, or any regular file with the specified extension. For example, an extension argument of "xml" would match regular files test.xml and TEST.XML2 and it will match directories regardless of name. brickKThe function used to determine what kinds of entries can be selected (see .). A good default is !). This can be changed at 'any time with  or its 'corresponding lens.brick?The resource name associated with the browser's entry listing.brickThe initial working directory that the browser displays. If not provided, this defaults to the executable's current working directory.%brickHThe name of the file to inspect. This filename is only used to set the  and sanitized filename fields; the actual file to be inspected is referred to by the second argument. This is decomposed so that ;s can be used to represent information about entries like ..8, whose display names differ from their physical paths.brick:The actual full path to the file or directory to inspect.*brickThe search transformation. - indicates that search mode should be off; U indicates that it should be on and that the provided search string should be used.brickThe browser to modify.+brickA file size in bytes./brick)Whether the file browser has input focus.brickThe browser to render.:      !"#$%&'()*+,-./0123456789:;<:      !"$'*#./-()&012:3456789;<+,%#None)  !"#$%&'()*+,      !"#$%&')*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`None&'SX&'=brickfA form: a sequence of input fields that manipulate the fields of an underlying state that you choose.Type variables are as follows:sc - the data type of your choosing containing the values manipulated by the fields in this form.e - your application's event typen( - your application's resource name type>brickJThe focus ring for the form, indicating which form field has input focus.?brick9The current state of the form. Forms guarantee that only valid inputs ever get stored in the state, and that after each input event on a form field, if that field contains a valid state value then the value is immediately saved to its corresponding field in this state value using the form field's lens over s.brick8Concatenation function for this form's field renderings.@brickA form field state accompanied by the fields that manipulate that state. The idea is that some record field in your form state has one or more form fields that manipulate that value. This data type maps that state field (using a lens into your state) to the form input fields responsible for managing that state field, along with a current value for that state field and an optional function to control how the form inputs are rendered.Most form fields will just have one input, such as text editors, but others, such as radio button collections, will have many, which is why this type supports more than one input corresponding to a state field.Type variables are as follows:sK - the data type containing the value manipulated by these form fields.e - your application's event typen( - your application's resource name typeBbrickThe current state value associated with the field collection. Note that this type is existential. All form fields in the collection must validate to this type.Cbrick\A lens to extract and store a successfully-validated form input back into your form state.Dbrick\The form fields, in order, that the user will interact with to manipulate this state value.EbrickA helper function to augment the rendered representation of this collection of form fields. It receives the default representation and can augment it, for example, by adding a label on the left.Fbrick:Concatenation function for this field's input renderings.GbrickA form field. This represents an interactive input field in the form. Its user input is validated and thus converted into a type of your choosing.Type variables are as follows:aK - the type of the field in your form state that this field manipulatesb' - the form field's internal state typee - your application's event typen( - your application's resource name typeIbrick%The name identifying this form field.JbrickTA validation function converting this field's state into a value of your choosing. NothingG indicates a validation failure. For example, this might validate an fD state value by parsing its text contents s aan integer and return  X. This is for pure avalue validation; if additional validation is required a(e.g. via L), use this field's state value in an aexternal validation routine and use a) to afeed the result back into the form.KbrickaWhether the field is valid according to an external validation source. Defaults to always being  and can be set with a8. The value of this field also affects the behavior of _ and .Lbrick{A function to render this form field. Parameters are whether the field is currently focused, followed by the field state.MbrickmAn event handler for this field. This receives the event and the field state and returns a new field state.NbrickCompose a new rendering augmentation function with the one in the form field collection. For example, we might put a label on the left side of a form field: F(str "Please check: " <+>) @@= checkboxField alive AliveField "Alive?"JThis can also be used to add multiple augmentations and associates right: h(withDefAttr someAttribute) @@= (str "Please check: " <+>) @@= checkboxField alive AliveField "Alive?"Obrick Set the focused field of a form.Pbrick*Set a form field's concatenation function.Qbrick$Set a form's concatenation function.RbrickCreate a new form with the specified input fields and an initial form state. The fields are initialized from the state using their state lenses and the first form input is focused initially.Sbrick@A form field for manipulating a boolean value. This represents  as  [X] label and  as  [ ] label.This field responds to Space8 keypresses to toggle the checkbox and to mouse clicks.Tbrick@A form field for manipulating a boolean value. This represents  as  [X] label and  as  [ ] label2. This function permits the customization of the [X] notation characters.This field responds to Space8 keypresses to toggle the checkbox and to mouse clicks.UbrickmA form field for selecting a single choice from a set of possible choices in a scrollable list. This uses a  internally.4This field responds to the same input events that a  does.VbrickA form field for selecting a single choice from a set of possible choices. Each choice has an associated value and text label.This field responds to SpaceA keypresses to select a radio button option and to mouse clicks.WbrickA form field for selecting a single choice from a set of possible choices. Each choice has an associated value and text label. This function permits the customization of the [*] notation characters.This field responds to SpaceA keypresses to select a radio button option and to mouse clicks.XbrickA form field for using an editor to edit the text representation of a value. The other editing fields in this module are special cases of this function.-This field responds to all events handled by n, including mouse events.Ybrick4A form field using a single-line editor to edit the 0 representation of a state field value of type a. This automatically uses its  instance to validate the input. This field is mostly useful in cases where the user-facing representation of a value matches the & representation exactly, such as with .-This field responds to all events handled by n, including mouse events.ZbrickjA form field using an editor to edit a text value. Since the value is free-form text, it is always valid.-This field responds to all events handled by n, including mouse events.[brickA form field using a single-line editor to edit a free-form text value represented as a password. The value is always considered valid and is always represented with one asterisk per password character.-This field responds to all events handled by n, including mouse events.\brick,The namespace for the other form attributes.]brick8The attribute for form input fields with invalid values.^brick8The attribute for form input fields that have the focus._brickReturns whether all form fields in the form currently have valid values according to the fields' validation functions. This is useful when we need to decide whether the form state is up to date with respect to the form input fields.`brickReturns the resource names associated with all form input fields that currently have invalid inputs. This is useful when we need to force the user to repair invalid inputs before moving on from a form editing session.abrickManually indicate that a field has invalid contents. This can be useful in situations where validation beyond the form element's validator needs to be performed and the result of that validation needs to be fed back into the form state.bbrickRender a form.dFor each form field, each input for the field is rendered using the implementation provided by its GR. The inputs are then concatenated with the field's concatenation function (see PV) and are then augmented using the form field's rendering augmentation function (see Nt). Fields with invalid inputs (either due to built-in validator failure or due to external validation failure via a) will be displayed using the ] attribute.mFinally, all of the resulting field renderings are concatenated with the form's concatenation function (see Q).cbrickERender a single form field collection. This is called internally by bU but is exposed in cases where a form field state needs to be rendered outside of a =, so b is probably what you want.dbrickxDispatch an event to the appropriate form field and return a new form. This handles the following events in this order:On TabE keypresses, this changes the focus to the next field in the form.On  Shift-TabI keypresses, this changes the focus to the previous field in the form.On mouse button presses (regardless of button or modifier), the focus is changed to the clicked form field and the event is forwarded to the event handler for the clicked form field.On Left or Up, if the currently-focused field is part of a collection (e.g. radio buttons), the previous entry in the collection is focused.On Right or Down, if the currently-focused field is part of a collection (e.g. radio buttons), the next entry in the collection is focused.CAll other events are forwarded to the currently focused form field.In all cases where an event is forwarded to a form field, validation of the field's input state is performed immediately after the event has been handled. If the form field's input state succeeds validation using the field's validator function, its value is immediately stored in the form state using the form field's state lens. The external validation flag is ignored during this step to ensure that external validators have a chance to get the intermediate validated value. RbricktThe form field constructors. This is intended to be populated using the various field constructors in this module.brick3The initial form state used to populate the fields.SbrickThe state lens for this value.brick&The resource name for the input field.brick4The label for the check box, to appear at its right.brickThe initial form state.TbrickLeft bracket character.brickCheckmark character.brickRight bracket character.brickThe state lens for this value.brick&The resource name for the input field.brick4The label for the check box, to appear at its right.brickThe initial form state.UbrickPossible choices.brick;The state lens for the initially/finally selected element.brickList item rendering function.brickList item height in rows.brick&The resource name for the input field.brickThe initial form state.VbrickThe state lens for this value.brickBThe available choices, in order. Each choice has a value of type a$, a resource name, and a text label.brickThe initial form state.WbrickThe state lens for this value.brickBThe available choices, in order. Each choice has a value of type a$, a resource name, and a text label.brickThe initial form state.XbrickThe state lens for this value.brick&The resource name for the input field.brick,The optional line limit for the editor (see n).brickThe initialization function that turns your value into the editor's initial contents. The resulting text may contain newlines.brickWThe validation function that converts the editors contents into a valid value of type a.brick7The rendering function for the editor's contents (see s).brickWA rendering augmentation function to adjust the representation of the rendered editor.brickThe initial form state.YbrickThe state lens for this value.brick&The resource name for the input field.brickThe initial form state.ZbrickThe state lens for this value.brick&The resource name for the input field.brick,The optional line limit for the editor (see n).brickThe initial form state.[brickThe state lens for this value.brick&The resource name for the input field.brickThe initial form state.abrick&Whether the field is considered valid.brick/The name of the form field to set as (in)valid.brickThe form to modify.(=?>@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd(=@ABCDEFGHIJKLMR>?dbcN_`aQPOZY[VSUXWT\]^N5SafeebrickMarkup with metadata type a assigned to each character.fbrickaBuild a piece of markup; assign the specified metadata to every character in the specified text.gbrick1Build markup from text with the default metadata.hbrick=Extract the text from markup, discarding the markup metadata.ibrick!Test whether the markup is empty.jbrickySet the metadata for a range of character positions in a piece of markup. This is useful for, e.g., syntax highlighting.kbrickConvert markup to a list of lines. Each line is represented by a list of pairs in which each pair contains the longest subsequence of characters having the same metadata.lbrick6Convert a list of text and metadata pairs into markup.efghijklekjlghifNoneiqbrick~A type class for types that provide access to an attribute in the rendering monad. You probably won't need to instance this.rbrick7Where to get the attribute for this attribute metadata.sbrickBuild a piece of markup from text with an assigned attribute name. When the markup is rendered, the attribute name will be looked up in the rendering context's ; to determine the attribute to use for this piece of text.tbrickBuild a widget from markup.eqrstetsqr$%&'()*+,-./0123456789:;<=>?@ABCCDEEFGHIJKLMNOOPQRSTTUVVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyyz{|}~      !"#$%&'()*+,-./0123456789: ; < = > ? @ 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 { | } ~                                  "                                !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJJKLMNOPPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     ~ ~~~!brick-0.48-Bn2iD72BIF4Dybvbz6VPY2 Brick.AttrMap Brick.BChan Brick.TypesBrick.BorderMap Brick.ThemesBrick.Widgets.Border.Style Data.IMap Brick.Util Brick.MainBrick.Widgets.CoreBrick.Widgets.ProgressBarBrick.Widgets.EditBrick.Widgets.CenterBrick.Widgets.BorderBrick.Widgets.Dialog Brick.FocusBrick.Widgets.ListBrick.Widgets.FileBrowser Brick.FormsData.Text.Markup Brick.MarkupBrick.Types.TH Control.Lens makeLensesBrick.Types.CommonBrick.Types.InternallookupViewportBrick.Widgets.InternalEventM Data.TextZipperListEditappChooseCursorBrickAttrMapAttrNameattrNameattrNameComponentsattrMap forceAttrMapmergeWithDefault attrMapLookupsetDefaultAttrgetDefaultAttrapplyAttrMappings mapAttrName mapAttrNames$fIsStringAttrName$fMonoidAttrName$fSemigroupAttrName$fShowAttrName$fReadAttrName $fEqAttrName $fOrdAttrName$fGenericAttrName$fNFDataAttrName $fShowAttrMap$fGenericAttrMap$fNFDataAttrMapBChannewBChan writeBChan readBChan readBChan2 suffixLensesLocationlocEdgeseTopeBottomeLefteRightlocLeBottomLeLeftLeRightLeTopLThemethemeDefaultAttrthemeDefaultMappingthemeCustomDefaultAttrthemeCustomMappingThemeDocumentationthemeDescriptions CustomAttrcustomFgcustomBg customStyle$fMonoidCustomAttr$fSemigroupCustomAttr$fEqCustomAttr$fReadCustomAttr$fShowCustomAttr$fGenericCustomAttr$fNFDataCustomAttr$fEqThemeDocumentation$fReadThemeDocumentation$fShowThemeDocumentation$fGenericThemeDocumentation$fNFDataThemeDocumentation $fEqTheme $fReadTheme $fShowTheme$fGenericTheme $fNFDataTheme customBgL customFgL customStyleLthemeCustomDefaultAttrLthemeCustomMappingLthemeDefaultAttrLthemeDefaultMappingLthemeDescriptionsLnewThemethemeToAttrMapapplyCustomizationsloadCustomizationssaveCustomizations saveTheme BorderStyle bsCornerTL bsCornerTR bsCornerBR bsCornerBLbsIntersectFull bsIntersectL bsIntersectR bsIntersectT bsIntersectB bsHorizontal bsVerticaldefaultBorderStyleborderStyleFromCharasciiunicode unicodeBoldunicodeRounded$fShowBorderStyle$fReadBorderStyle$fEqBorderStyle$fGenericBorderStyle$fNFDataBorderStyleRunlenvalIMap unsafeRunsemptynull singletoninsertdeleterestrictlookupsplitLE addToKeysintersectionWithmapMaybefromListunsafeToAscList unsafeUnion$fTraversableRun $fFoldableRun$fApplicativeIMap $fOrdIMap$fEqIMap$fEqRun$fOrdRun $fReadRun $fShowRun $fFunctorRun $fGenericRun $fNFDataRun $fShowIMap $fFunctorIMap $fReadIMap $fGenericIMap $fNFDataIMap BorderMapemptyCoordinates coordinatesboundsvaluesinsertHinsertV lookupRow lookupCollookupHlookupVsetCoordinatescropexpand translate $fEqBorderMap$fOrdBorderMap$fShowBorderMap$fFunctorBorderMap$fReadBorderMap$fGenericBorderMap$fNFDataBorderMap BorderSegmentbsAcceptbsOfferbsDrawCursorLocationcursorLocationcursorLocationNameTerminalLocationlocationColumnLlocationColumn locationRowL locationRow DirectionUpDownNextExtent extentNameextentUpperLeft extentSize extentOffset ViewportTypeVertical HorizontalBothViewportVP_vpLeft_vpTop_vpSizeVisibilityRequestVR vrPositionvrSize DynBorderdbStyledbAttr dbSegments bsAcceptLbsDrawLbsOfferLResultimagecursorsvisibilityRequestsextentsbordersdbAttrL dbSegmentsLdbStyleLContext ctxAttrName availWidth availHeightctxBorderStyle ctxAttrMap ctxDynBorders RenderState BrickEventVtyEventAppEvent MouseDownMouseUpbordersLcursorsLextentsLimageLvisibilityRequestsL emptyResult vrPositionLvrSizeLcursorLocationLcursorLocationNameLvpLeftvpSizevpTopclamponfgbgclOffsetRenderMWidgethSizevSizerenderSizeFixedGreedy runEventMPaddingPadMaxhandleEventLensed getContext$fFunctorEventM$fApplicativeEventM $fMonadEventM$fMonadIOEventM $fShowSize$fEqSize $fOrdSize availHeightL availWidthL ctxAttrMapL ctxAttrNameLctxBorderStyleLctxDynBordersLattrLlookupAttrName $fTerminalLocationCursorLocation renderFinal cropToContextNamedgetName TextWidth textWidthwithBorderStyle joinBordersseparateBorders freezeBorders emptyWidgetaddResultOffset reportExtent clickablestrWrap strWrapWithtxtWrap txtWrapWithstrtxt hyperlinkpadLeftpadRightpadTop padBottom padLeftRight padTopBottompadAllfillvBoxhBoxhLimit hLimitPercentvLimit vLimitPercentsetAvailableSizewithAttr modifyDefAttr withDefAttr updateAttrMap forceAttr overrideAttrraw translateBy cropLeftBy cropRightBy cropTopBy cropBottomBy showCursorcachedviewportunsafeLookupViewportvisible visibleRegion<+><=> $fTextWidthf$fTextWidthTextprogressCompleteAttrprogressIncompleteAttr progressBarEditor editContents editorName DecodeUtf8 decodeUtf8 editContentsLhandleEditorEvent editorTexteditor applyEditeditAttreditFocusedAttrgetEditContents renderEditor$fNamedEditorn $fShowEditor$fDecodeUtf8[]$fDecodeUtf8TexthCenter hCenterLayer hCenterWithvCenter vCenterLayer vCenterWithcenter centerWith centerLayer centerAbout borderAttr borderElemborderborderWithLabelhBorderhBorderWithLabelvBorderjoinableBorderDialog dialogTitle dialogButtonsdialogSelectedIndex dialogWidthdialogButtonsLdialogSelectedIndexL dialogTitleL dialogWidthLhandleDialogEventdialog dialogAttr buttonAttrbuttonSelectedAttr renderDialogdialogSelection FocusRing focusRing focusNext focusPrev withFocusRingfocusGetCurrentfocusSetCurrentfocusRingModifyfocusRingCursorViewportScroll hScrollPage hScrollByhScrollToBeginning hScrollToEnd vScrollPage vScrollByvScrollToBeginning vScrollToEndsetTopsetLeftAppappDrawappHandleEvent appStartEvent appAttrMap defaultMain simpleMain simpleApp resizeOrQuit customMaincustomMainWithVty clickedExtent lookupExtentfindClickedExtents getVtyHandleinvalidateCacheEntryinvalidateCachegetRenderStateresetRenderStateneverShowCursorshowFirstCursorshowCursorNamedviewportScrollcontinuehaltsuspendAndResume GenericList listElements listSelectedlistNamelistItemHeight$fFunctorGenericList$fFoldableGenericList$fTraversableGenericList$fShowGenericList$fGenericGenericList Reversiblereverse SplittablesplitAtslice listElementsLlistItemHeightL listNameL listSelectedLhandleListEventhandleListEventVilistAttrlistSelectedAttrlistSelectedFocusedAttrlist renderListrenderListWithIndex listInsert listRemove listReplace listMoveUplistMovePageUp listMoveDownlistMovePageDownlistMoveByPages listMoveBy listMoveTolistMoveToElement listFindBylistSelectedElement listClear listReverse listModify$fNamedGenericListn$fSplittableSeq$fSplittableVector$fReversibleSeq$fReversibleVectorFileType RegularFile BlockDeviceCharacterDevice NamedPipe Directory SymbolicLink UnixSocketFileInfofileInfoFilenamefileInfoSanitizedFilenamefileInfoFilePathfileInfoFileStatus FileStatusfileStatusSizefileStatusFileType FileBrowserfileBrowserExceptionfileBrowserSelectable$fReadFileType$fShowFileType $fEqFileType$fShowFileStatus$fEqFileStatus$fShowFileInfo $fEqFileInfofileBrowserEntryFilterLfileBrowserSelectableLfileInfoFilePathLfileInfoFileStatusLfileInfoFilenameLfileInfoSanitizedFilenameLfileStatusFileTypeLfileStatusSizeLnewFileBrowserselectNonDirectoriesselectDirectoriessetFileBrowserEntryFiltersetWorkingDirectory getFileInfofileInfoFileTypegetWorkingDirectoryfileBrowserIsSearchingfileBrowserSelectionupdateFileBrowserSearchprettyFileSizeentriesForDirectoryfileBrowserCursorhandleFileBrowserEventrenderFileBrowserfileBrowserAttrfileBrowserCurrentDirectoryAttrfileBrowserSelectionInfoAttrfileBrowserDirectoryAttrfileBrowserBlockDeviceAttrfileBrowserRegularFileAttrfileBrowserCharacterDeviceAttrfileBrowserNamedPipeAttrfileBrowserSymbolicLinkAttrfileBrowserUnixSocketAttrfileBrowserSelectedAttr fileTypeMatchfileExtensionMatchForm formFocus formStateFormFieldStateformFieldState formFieldLens formFieldsformFieldRenderHelperformFieldConcat FormField formFieldNameformFieldValidateformFieldExternallyValidformFieldRenderformFieldHandleEvent@@= setFormFocussetFieldConcat setFormConcatnewForm checkboxFieldcheckboxCustomField listField radioFieldradioCustomField editFieldeditShowableField editTextFieldeditPasswordFieldformAttrinvalidFormInputAttrfocusedFormInputAttrallFieldsValid invalidFields setFieldValid renderFormrenderFormFieldStatehandleFormEventMarkup@@fromTexttoTextisEmpty markupSet markupToList$fIsStringMarkup$fMonoidMarkup$fSemigroupMarkup $fShowMarkupGetAttrgetAttr@?markup$fGetAttrAttrName $fGetAttrAttr!vty-5.25.1-67KOV8TNuJW448tppY0bnkGraphics.Vty.AttributesAttrbaseGHC.Basemappend<>origin parseColorcontainers-0.6.0.1Data.IntMap.InternalIntMapmapKeysMonotonic neighborsghc-prim GHC.TypesCharContinueSuspendAndResumeHalt EventStateESesScrollRequestscacheInvalidateRequestsCacheInvalidateRequestInvalidateSingleInvalidateEntire ScrollRequest HScrollBy HScrollPageHScrollToBeginning HScrollToEnd VScrollBy VScrollPageVScrollToBeginning VScrollToEndSetTopSetLeftEventROeventViewportMapeventVtyHandle latestExtentsoldStateRS viewportMaprsScrollRequests observedNames renderCacheclickableNamesclickableNamesLobservedNamesL renderCacheLrsScrollRequestsL viewportMapLcropResultToContextrenderDynBorder BoxRenderer Data.Foldablelength takeColumnsString text-1.2.3.1Data.Text.InternalText renderBox catBorders catAllBordersGraphics.Vty.Image DisplayRegion Data.EitherLeft GHC.MaybeNothingdynBorderFromDirections setDynBorders viewportNameGraphics.Vty.Input.EventsEvent Graphics.VtyVtyshutdown&vector-0.12.0.3-ChzWbiXyvuNAQj0dcU08Sg Data.VectorVectorData.Traversable Traversable Applicative SemigroupMonoiddrawListElementsData.Sequence.InternalSeqJust splitClamptraverseTrueFalsesanitizeFilename formConcatAllMaybeIntIOgetInvalidFieldsGHC.ShowShowGHC.ReadRead