h&pk      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      Safe-Inferred'*0158?C bytesmithA non-resumable parser. bytesmith%Fail with the provided error message. bytesmith"Combines the error messages using  when both parsers fail. bytesmith Error message Safe-Inferred!01    Safe-Inferred8:? bytesmithSlicing metadata (an offset and a length) accompanied by a value. This does not represent a slice into the value. This type is intended to be used as the result of an executed parser. In this context the slicing metadata describe a slice into to the array (or byte array) that from which the value was parsed. It is often useful to check the length when a parser succeeds since a non-zero length indicates that there was additional unconsumed input. The offset4 is only ever needed to construct a new slice (via Bytes or  SmallVector) from the remaining input. bytesmithOffset into the array. bytesmithLength of the slice. bytesmith1The structured data that was successfully parsed. bytesmithThe result of running a parser. bytesmith,An error message indicating what went wrong. bytesmithThe parsed value and the number of bytes remaining in parsed slice.  Safe-Inferred%'*0158?  bytesmithGet the current offset into the chunk. Using this makes it possible to observe the internal difference between . that refer to equivalent slices. Be careful. bytesmith Variant of  with unboxed result.  bytesmithReturn the byte array being parsed. This includes bytes that preceed the current offset and may include bytes that go beyond the length. This is somewhat dangerous, so only use this is you know what you're doing.! bytesmithMove the cursor back by n bytes. Precondition: you must have previously consumed at least n bytes." bytesmithSet the position to the given index. Precondition: the index must be valid. It should be the result of an earlier call to .  !"  !" Safe-Inferred*0158?'&# bytesmithParse a byte sequence. This can succeed even if the entire slice was not consumed by the parser.$ bytesmith Variant of %8 that discards the error message on failure. Just like %, this does not impose any checks on the length of the remaining input.% bytesmith Variant of # that discards the new offset and the remaining length. This does not, however, require the remaining length to be zero. Use > to accomplish that.& bytesmith Variant of # that accepts an unsliced .' bytesmith Variant of # that allows the parser to be run as part of an existing effectful context.( bytesmith,Lift an effectful computation into a parser.* bytesmith)Consume input matching the byte sequence.+ bytesmithConsume input matching the NUL-terminated C String., bytesmithInfix version of -.- bytesmithAnnotate a parser. If the parser fails, the error will be returned.. bytesmithConsumes and returns the next byte in the input. Fails if no characters are left./ bytesmith.Match any byte, to perform lookahead. Returns  if end of input has been reached. Does not consume any input.Note: Because this parser does not fail, do not use it with combinators such as many, because such as many, because such parsers loop until a failure occurs. Careless use will thus result in an infinite loop.0 bytesmithMatch any byte, to perform lookahead. Does not consume any input, but will fail if end of input has been reached.1 bytesmithA stateful scanner. The predicate consumes and transforms a state argument, and each transformed state is passed to successive invocations of the predicate on each byte of the input until one returns  or the input ends.This parser does not fail. It will return the initial state if the predicate returns  on the first byte of input.Note: Because this parser does not fail, do not use it with combinators such a many, because such parsers loop until a failure occurs. Careless use will thus result in an infinite loop.2 bytesmithTake while the predicate is matched. This is always inlined. This always succeeds.3 bytesmithTake bytes until the specified byte is encountered. Consumes the matched byte as well. Fails if the byte is not present. Visually, the cursor advancement and resulting Bytes for takeTrailedBy 0x19 look like this:  0x10 0x13 0x08 0x15 0x19 0x23 0x17 | input |---->---->---->---->----| | cursor {----*----*----*----} | result bytes4 bytesmithSkip all characters until the character from the is encountered and then consume the matching byte as well.5 bytesmithSkip all bytes until either of the bytes in encountered. Then, consume the matched byte. True: indicates that the first argument byte was encountered. False: indicates that the second argument byte was encountered.8 bytesmithTake the given number of bytes. Fails if there is not enough remaining input.9 bytesmith)Consume all remaining bytes in the input.: bytesmith?Return all remaining bytes in the input without consuming them.; bytesmith bytesmith-Fails if there is still more input remaining.? bytesmithReturns true if there are no more bytes in the input. Returns false otherwise. Always succeeds.@ bytesmith Convert a  parser to a  parser.A bytesmith Convert a  (Int,Int) parser to a (# Int#, Int# #) parser.B bytesmith Convert a  parser to a  parser. Precondition: the argument parser only returns words less than 4294967296. bytesmith Convert a (# Int#, Int# #) parser to a  (Int,Int) parser. bytesmith Convert a (# Int#, Int# #) parser to a  (Int,Int) parser.C bytesmith Convert a (# Int#, Int# #) parser to a  (Int,Int) parser.D bytesmith#There is a law-abiding instance of  Alternative for . However, it is not terribly useful since error messages seldom have a ) instance. This function is a variant of <|> that is right-biased in its treatment of error messages. Consequently, orElse lacks an identity. See  ,https://github.com/bos/attoparsec/issues/122attoparsec issue #122$ for more discussion of this topic.N bytesmithAugment a parser with the number of bytes that were consume while it executed.O bytesmithRun a parser and discard the result, returning instead the number of bytes that the parser consumed.P bytesmith Variant of O with an unboxed result.Q bytesmithRun a parser in a delimited context, failing if the requested number of bytes are not available or if the delimited parser does not consume all input. This combinator can be understood as a composition of 8, (, ', and >. It is provided as a single combinator because for convenience and because it is easy to make mistakes when manually assembling the aforementioned parsers. The pattern of prefixing an encoding with its length is common. This is discussed more in  ,https://github.com/bos/attoparsec/issues/129attoparsec issue #129. 'delimit e1 e2 n remaining === take e1 nR bytesmithReplicate a parser n5 times, writing the results into an array of length n. For Array and  SmallArray, this is lazy in the elements, so be sure the they result of the parser is evaluated appropriately to avoid unwanted thunks.5 bytesmith Error message bytesmithFirst trailer, False$ indicates that this was encountered bytesmithSecond trailer, True$ indicates that this was encountered6 bytesmith Error message bytesmith4First trailer, 0 indicates that this was encountered bytesmith5Second trailer, 1 indicates that this was encountered7 bytesmith Error message bytesmith4First trailer, 0 indicates that this was encountered bytesmith5Second trailer, 1 indicates that this was encountered bytesmith4Third trailer, 2 indicates that this was encounteredQ bytesmith/Error message when not enough bytes are present bytesmith>Error message when delimited parser does not consume all input bytesmith=Exact number of bytes delimited parser is expected to consume bytesmith&Parser to execute in delimited contextR bytesmith!Number of times to run the parser bytesmithParser7#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR7&#'%$.823;4567)*<=+>?9:1/0D-,RQNOP(BC@AEHGIFJKLM,0D3 Safe-Inferred*0158?/S bytesmithUnsigned 8-bit word.T bytesmithArray of little-endian unsigned 16-bit words. If the host is little-endian, the implementation is optimized to simply memcpy bytes into the result array. The result array always has elements in native-endian byte order.U bytesmith6Parse an array of little-endian unsigned 32-bit words.V bytesmith6Parse an array of little-endian unsigned 64-bit words.W bytesmith7Parse an array of little-endian unsigned 128-bit words.X bytesmith7Parse an array of little-endian unsigned 256-bit words.Y bytesmith4Parse an array of little-endian signed 64-bit words.Z bytesmithUnsigned 16-bit word.[ bytesmithUnsigned 32-bit word.\ bytesmithUnsigned 64-bit word.] bytesmithUnsigned 256-bit word.^ bytesmithUnsigned 128-bit word._ bytesmithSigned 8-bit integer.` bytesmithSigned 16-bit integer.a bytesmithSigned 32-bit integer.b bytesmithSigned 64-bit integer.T bytesmith-Error message if not enough bytes are present bytesmith.Number of little-endian 16-bit words to expect bytesmithNative-endian elementsU bytesmith-Error message if not enough bytes are present bytesmith/Number of little-endian 32-bit words to consume bytesmithNative-endian elementsV bytesmith-Error message if not enough bytes are present bytesmith/Number of little-endian 64-bit words to consume bytesmithNative-endian elementsW bytesmith-Error message if not enough bytes are present bytesmith0Number of little-endian 128-bit words to consume bytesmithNative-endian elementsX bytesmith-Error message if not enough bytes are present bytesmith0Number of little-endian 256-bit words to consume bytesmithNative-endian elementsY bytesmith-Error message if not enough bytes are present bytesmith.Number of little-endian 64-bit words to expect bytesmithNative-endian elementsSTUVWXYZ[\]^_`abSZ[\^]_`abTUVWXY Safe-Inferred3c bytesmith>Parse a LEB-128-encoded number. If the number is larger than 0xFFFF , fails with the provided error.d bytesmith>Parse a LEB-128-encoded number. If the number is larger than  0xFFFFFFFF , fails with the provided error.e bytesmith>Parse a LEB-128-encoded number. If the number is larger than 0xFFFFFFFFFFFFFFFF , fails with the provided error.f bytesmithParse a LEB-128-zigzag-encoded signed number. If the encoded number is outside the range [-32768,32767]&, this fails with the provided error.g bytesmithParse a LEB-128-zigzag-encoded signed number. If the encoded number is outside the range [-2147483648,2147483647]&, this fails with the provided error.h bytesmithParse a LEB-128-zigzag-encoded signed number. If the encoded number is outside the range *[-9223372036854775808,9223372036854775807]&, this fails with the provided error.cdefghcdefgh Safe-Inferred*0158?[12i bytesmithRuns the predicate on the next character in the input. If the predicate is matched, this consumes the character. Otherwise, the character is not consumed. This returns False= if the end of the input has been reached. This never fails.j bytesmithRuns the function on the next character in the input. If the function returns Just, this consumes the character and then runs the parser on the remaining input. If the function returns Nothing, this does not consume the tested character, and it runs the default parser on the input (which includes the tested character). If there is no input remaining, this also runs the default parser. This combinator never fails.k bytesmithConsume the next character, failing if it does not match the expected value or if there is no more input.l bytesmithConsume the next two characters, failing if they do not match the expected values. $char2 e a b === char e a *> char e bm bytesmithConsume three characters, failing if they do not match the expected values. 2char3 e a b c === char e a *> char e b *> char e cn bytesmithConsume four characters, failing if they do not match the expected values. char4 e a b c d === char e a *> char e b *> char e c *> char e do bytesmithConsume five characters, failing if they do not match the expected values.p bytesmithConsume six characters, failing if they do not match the expected values.q bytesmithConsume seven characters, failing if they do not match the expected values.r bytesmithConsume eight characters, failing if they do not match the expected values.s bytesmithConsume nine characters, failing if they do not match the expected values.t bytesmithConsume ten characters, failing if they do not match the expected values.u bytesmithConsume eleven characters, failing if they do not match the expected values.v bytesmithConsume twelve characters, failing if they do not match the expected values.w bytesmith5Consumes and returns the next character in the input.x bytesmith-Consume a character from the input or return Nothing if end of the stream has been reached. Since ISO 8859-1 maps every bytes to a character, this parser never fails.y bytesmith Variant of opt with unboxed result.z bytesmith Variant of {1 that requires at least one digit to be present.{ bytesmithSkip the characters 0-9> until a non-digit is encountered. This parser does not fail.| bytesmithSkip the character any number of times. This succeeds even if the character was not present.} bytesmithSkip the character any number of times. It must occur at least once or else this will fail.~ bytesmithParse a decimal-encoded 8-bit word. If the number is larger than 255, this parser fails. bytesmithParse a hexadecimal-encoded 8-bit word. If the number is larger than 255, this parser fails. This allows leading zeroes and is insensitive to case. For example, 00A, 0a and A+ would all be accepted as the same number. bytesmithParse a hexadecimal-encoded 16-bit word. If the number is larger than 65535, this parser fails. This allows leading zeroes and is insensitive to case. For example, 0100a and 100A, would both be accepted as the same number. bytesmithParse a decimal-encoded 16-bit word. If the number is larger than 65535, this parser fails. bytesmithParse a decimal-encoded 32-bit word. If the number is larger than 4294967295, this parser fails. bytesmithParse a decimal-encoded number. If the number is too large to be represented by a machine word, this fails with the provided error message. This accepts any number of leading zeroes. bytesmithParse a decimal-encoded unsigned number. If the number is too large to be represented by a 64-bit word, this fails with the provided error message. This accepts any number of leading zeroes. bytesmithParse a decimal-encoded number. If the number is too large to be represented by a machine integer, this fails with the provided error message. This rejects input with that is preceeded by plus or minus. Consequently, it does not parse negative numbers. Use  or ) for that purpose. On a 64-bit platform 4 will successfully parse 9223372036854775808 (i.e. 2 ^ 63), but / will fail. This parser allows leading zeroes. bytesmith Variant of  with an unboxed result. bytesmithParse a decimal-encoded number. If the number is too large to be represented by a machine integer, this fails with the provided error message. This allows the number to optionally be prefixed by plus or minus. If the sign prefix is not present, the number is interpreted as positive. This allows leading zeroes. bytesmith Variant of  that lets the caller supply a leading digit. This is useful when parsing formats like JSON where integers with leading zeroes are considered invalid. The calling context must consume the first digit before calling this parser. Results are always positive numbers. bytesmithParse a decimal-encoded number. If the number is too large to be represented by a machine integer, this fails with the provided error message. This allows the number to optionally be prefixed by minus. If the minus prefix is not present, the number is interpreted as positive. The disallows a leading plus sign. For example,  rejects +42, but  allows it. bytesmith Variant of  that lets the caller supply a leading digit. This is useful when parsing formats like JSON where integers with leading zeroes are considered invalid. The calling context must consume the first digit before calling this parser. Results are always positive numbers. bytesmithParse a decimal-encoded positive integer of arbitrary size. This rejects input that begins with a plus or minus sign. bytesmithParse a decimal-encoded integer of arbitrary size. This accepts input that begins with a plus or minus sign. Input without a sign prefix is interpreted as positive. bytesmithTake characters until the specified character is encountered. Consumes the matched character as well. Fails if the character is not present. Visually, the cursor advancement and resulting Bytes for takeTrailedBy 'D' look like this:  A B C D E F | input |->->->-| | cursor {-*-*-} | result bytes bytesmithSkip all characters until the terminator is encountered and then consume the matching character as well. Visually, skipTrailedBy 'C' advances the cursor like this:  A Z B Y C X C W |->->->->-|This fails if it reaches the end of input without encountering the character. bytesmithSkip all characters until the terminator is encountered. This does not consume the terminator. Visually,  skipUntil 'C' advances the cursor like this:  A Z B Y C X C W |->->->-|This succeeds if it reaches the end of the input without encountering the terminator. It never fails. bytesmithParse exactly eight ASCII-encoded characters, interpreting them as the hexadecimal encoding of a 32-bit number. Note that this rejects a sequence such as BC5A9 , requiring 000BC5A9& instead. This is insensitive to case. bytesmithParse exactly 16 ASCII-encoded characters, interpreting them as the hexadecimal encoding of a 64-bit number. Note that this rejects a sequence such as BC5A9 , requiring 00000000000BC5A9' instead. This is insensitive to case. bytesmithParse exactly four ASCII-encoded characters, interpreting them as the hexadecimal encoding of a 16-bit number. Note that this rejects a sequence such as 5A9 , requiring 05A9 instead. This is insensitive to case. This is particularly useful when parsing escape sequences in C or JSON, which allow encoding characters in the Basic Multilingual Plane as \uhhhh. bytesmithParse exactly two ASCII-encoded characters, interpretting them as the hexadecimal encoding of a 8-bit number. Note that this rejects a sequence such as A , requiring 0A' instead. This is insensitive to case. bytesmithConsume a single character that is the lowercase hexadecimal encoding of a 4-bit word. Fails if the character is not in the class [a-f0-9]. bytesmithConsume a single character that is the case-insensitive hexadecimal encoding of a 4-bit word. Fails if the character is not in the class  [a-fA-F0-9]. bytesmithConsume a single character that is the lowercase hexadecimal encoding of a 4-bit word. Returns Nothing< without consuming the character if it is not in the class [a-f0-9]. The parser never fails. bytesmithConsume a single character that is the case-insensitive hexadecimal encoding of a 4-bit word. Returns Nothing< without consuming the character if it is not in the class  [a-fA-F0-9]. This parser never fails. bytesmith?ijklmnopqrstuvwxyz{|}~5klmnopqrstuvijwxy{z|}>?~ Safe-Inferred*0158?b  bytesmithConsume the next character, failing if it does not match the expected value or if there is no more input. This check for equality is case insensitive.-Precondition: The argument must be a letter ([a-zA-Z]'). Behavior is undefined if it is not. bytesmithConsume input until the trailer is found. Then, consume the trailer as well. This fails if the trailer is not found or if any non-ASCII characters are encountered. bytesmithConsume characters matching the predicate. The stops when it encounters a non-matching character or when it encounters a byte above 0x7F. This never fails. bytesmithConsume input through the next occurrence of the target character and return the consumed input, excluding the target character, as a /. This fails if it encounters any bytes above 0x7F. bytesmith5Consumes and returns the next character in the input. bytesmith Variant of  with unboxed result. bytesmithExamine the next byte without consuming it, interpret it as an ASCII-encoded character. This fails if the byte is above 0x7F* or if the end of input has been reached. bytesmithConsume the next byte, interpreting it as an ASCII-encoded character. Fails if the byte is above 0x7F . Returns Nothing+ if the end of the input has been reached. bytesmithConsume characters matching the predicate. The stops when it encounters a non-matching character or when it encounters a byte above 0x7F. This never fails. bytesmithSkip uppercase and lowercase letters until a non-alpha character is encountered. bytesmithSkip uppercase and lowercase letters until a non-alpha character is encountered.klmnz{|}~klmn{z|}~ Safe-Inferred*0158?j, bytesmithUnsigned 8-bit word. bytesmithParse an array of big-endian unsigned 16-bit words. If the host is big-endian, the implementation is optimized to simply memcpy bytes into the result array. The result array always has elements in native-endian byte order. bytesmith3Parse an array of big-endian unsigned 32-bit words. bytesmith3Parse an array of big-endian unsigned 64-bit words. bytesmith4Parse an array of big-endian unsigned 256-bit words. bytesmith4Parse an array of big-endian unsigned 128-bit words. bytesmithUnsigned 16-bit word. bytesmithUnsigned 32-bit word. bytesmithUnsigned 64-bit word. bytesmithUnsigned 128-bit word. bytesmithUnsigned 256-bit word. bytesmithSigned 8-bit integer. bytesmithSigned 16-bit integer. bytesmithSigned 32-bit integer. bytesmithSigned 64-bit integer. bytesmith-Error message if not enough bytes are present bytesmith+Number of big-endian 16-bit words to expect bytesmithNative-endian elements bytesmith-Error message if not enough bytes are present bytesmith+Number of big-endian 32-bit words to expect bytesmithNative-endian elements bytesmith-Error message if not enough bytes are present bytesmith,Number of big-endian 64-bit words to consume bytesmithNative-endian elements bytesmith-Error message if not enough bytes are present bytesmith-Number of big-endian 256-bit words to consume bytesmithNative-endian elements bytesmith-Error message if not enough bytes are present bytesmith-Number of big-endian 128-bit words to consume bytesmithNative-endian elements  Safe-Inferredj  Safe-Inferred*0158?k bytesmithInterpret the next one to four bytes as a UTF-8-encoded character. Fails if the decoded codepoint is in the range U+D800 through U+DFFF. bytesmithConsume input that matches the argument. Fails if the input does not match.      !"#$ % % & ' ()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmefgklmnopqrstuvwxyz{9|}~>?F:;?9:|F^_`acbefgihjklm e f g         & ' (                (bytesmith-0.3.9.1-DU7knYEFHuI3JS4aeyaLlDData.Bytes.Parser.UnsafeData.Bytes.ParserData.Bytes.Parser.RebindableData.Bytes.Parser.LittleEndianData.Bytes.Parser.Leb128Data.Bytes.Parser.LatinData.Bytes.Parser.AsciiData.Bytes.Parser.BigEndianData.Bytes.Parser.Base128Data.Bytes.Parser.Utf8Data.Bytes.Parser.InternalData.Bytes.Parser.TypesParser runParser uneffectfulfailPurepureBind>>=>>$fBindBoxedRepIntRep$fBindIntRepTupleRep$fBindBoxedRepTupleRep$fBindBoxedRepTupleRep0$fBindIntRepTupleRep0$fBindTupleRepBoxedRep$fBindTupleRepTupleRep$fBindTupleRepBoxedRep0$fBindIntRepBoxedRep$fBindWordRepBoxedRep$fBindBoxedRepBoxedRep$fPureTupleRep$fPureTupleRep0 $fPureIntRep$fPureBoxedRepSliceResultFailureSuccesscursorcursor#expose unconsumejump parseBytesparseBytesMaybeparseBytesEitherparseByteArrayparseBytesEffectfullyeffect byteArraybytescstringannotateanypeekpeek'scan takeWhile takeTrailedBy skipTrailedByskipTrailedBy2skipTrailedBy2#skipTrailedBy3#take remaining peekRemaining skipWhilesatisfy satisfyWith endOfInput isEndOfInput unboxWord32 unboxIntPair boxWord32 boxIntPairorElsebindFromCharToLiftedbindFromCharToIntPairbindFromLiftedToIntbindFromLiftedToIntPairbindFromIntToIntPairbindFromMaybeCharToIntPairbindFromMaybeCharToLifted pureIntPair failIntPairmeasuremeasure_ measure_#delimit replicateword8 word16Array word32Array word64Array word128Array word256Array int64Arrayword16word32word64word256word128int8int16int32int64 trySatisfytrySatisfyThencharchar2char3char4char5char6char7char8char9char10char11char12optopt# skipDigits1 skipDigitsskipChar skipChar1decWord8hexWord8 hexWord16 decWord16 decWord32decWord decWord64decUnsignedIntdecUnsignedInt# decSignedIntdecTrailingIntdecTrailingInt#decStandardIntdecTrailingIntegerdecUnsignedIntegerdecSignedInteger skipUntilhexFixedWord32hexFixedWord64hexFixedWord16 hexFixedWord8hexNibbleLower hexNibbletryHexNibbleLower tryHexNibblecharInsensitivetakeShortWhileshortTrailedByany# skipAlpha skipAlpha1 shortText$fAlternativeParserbaseGHC.Base<>Result#ST#Bytes# InternalStep unfailingboxBytes unboxBytes unboxResultindexLatinCharArray uneffectful#uneffectfulInt#upcastUnitSuccess swapArray16 swapArray32 swapArray64 swapArray128 swapArray256offsetlengthvalue(byteslice-0.2.9.0-CcoijRvkvMH5VvEM95LRntData.Bytes.InternalBytes'primitive-0.7.4.0-5Mou7sRsTgfjuEOfjOZOzData.Primitive.ByteArray ByteArray GHC.MaybeNothingghc-prim GHC.TypesTrueGHC.WordWord32GHC.PrimWord#boxIntboxBoolMonoid&text-short-0.1.5-47pdwYBqw8IixyiOFqnKOData.Text.Short.Internal ShortText