h&^~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~             Safe-Inferred6B tar3The most significant bit is used for tagging, see  / $ below, so morally it's Word31 only.tar1A compact mapping from sequences of nats to nats.+NOTE: The tries in this module have values only at the leaves (which correspond to files), they do not have values at the branch points (which correspond to directories).tarConvert the trie to a listThis is the left inverse to  (modulo ordering).tar Build an  from a bunch of (key, value) pairs, where the keys are sequences.      Safe-Inferred6 O0tar=An efficient mapping from strings to a dense set of integers.2tarLook up a string in the token table. If the string is present, return its corresponding index.4tar01245/6789:;<=>3 Safe-Inferred CtarWe should really migrate to OsPath from filepath7 package, but for now let's not corrupt data silently.CC(c) 2007 Bjorn Bringert, 2008 Andrea Vezzosi, 2008-2009 Duncan Coutts 2011 Max BolingbrokeBSD3duncan@community.haskell.orgportable Safe-Inferred 89:1a;DtarMonomorphic sequence of archive entries, ready for serialization / deserialization.EtarPolymorphic sequence of archive entries. High-level interfaces commonly work with E  , while low level uses E O I.The point of this type as opposed to just using a list is that it makes the failure case explicit. We need this because the sequence of entries we get from reading a tarball can include errors.-Converting from a list can be done with just foldr Next Done0. Converting back into a list can be done with : however in that case you must be prepared to handle the H case inherent in the D type.The  instance lets you concatenate archives or append entries to an archive.Itar8The tar format allows just 100 ASCII characters for the _ and ` entry types.KtarReturn type of .Ltar was empty, but O must be non-empty.Mtar All good, this is just a normal O.Ntar! was longer than 255 characters, O contains a truncated part only. An actual entry must be preceded by |.OtarThe classic tar format allowed just 100 characters for the file name. The USTAR format extended this with an extra 155 characters, however it uses a complex method of splitting the name between the two sections.Instead of just putting any overflow into the extended area, it uses the extended area as a prefix. The aggravating insane bit however is that the prefix (if any) must only contain a directory prefix. That is the split between the two areas must be on a directory separator boundary. So there is no simple calculation to work out if a file name is too long. Instead we have to try to find a valid split that makes the name fit in the two areas.The rationale presumably was to make it a bit more compatible with old tar programs that only understand the classic format. A classic tar would be able to extract the file name and possibly some dir prefix, but not the full dir prefix. So the files would end up in the wrong place, but that's probably better than ending up with the wrong names too.+So it's understandable but rather annoying.Tar paths use Posix format (ie '/' directory separators), irrespective of the local path conventions.7The directory separator between the prefix and name is not stored.QtarThere have been a number of extensions to the tar file format over the years. They all share the basic entry fields and put more meta-data in different extended headers.RtarThis is the classic Unix V7 tar format. It does not support owner and group names, just numeric Ids. It also does not support device numbers.StarThe "USTAR" format is an extension of the classic V7 format. It was later standardised by POSIX. It has some restrictions but is the most portable format.TtarThe GNU tar implementation also extends the classic V7 format, though in a slightly different way from the USTAR format. This is the only format supporting long file names.Wtar&The owner user name. Should be set to "" if unknown.Xtar'The owner group name. Should be set to "" if unknown.Ytar(Numeric owner user id. Should be set to 0 if unknown.Ztar)Numeric owner group id. Should be set to 0 if unknown.[tarMonomorphic content of a tar archive entry, ready for serialization / deserialization.\tarPolymorphic content of a tar archive entry. High-level interfaces commonly work with \ , while low level uses \ I.&Portable archives should contain only ] and ^.etarMonomorphic tar archive entry, ready for serialization / deserialization.ftarPolymorphic tar archive entry. High-level interfaces commonly work with f  , while low level uses f O I.htar5The path of the file or directory within the archive.itar#The real content of the entry. For ]; this includes the file data. An entry usually contains a ] or a ^.jtar(File permissions (Unix style file mode).ktar.The user and group to which this file belongs.ltar$The time the file was last modified.mtar$The tar format the archive is using.rtar*The number of seconds since the UNIX epochttarNative - of the file or directory within the archive.utar rw-r--r-- for normal filesvtar rw-r--r-- for normal fileswtar rwxr-xr-x for executable filesxtar rwxr-xr-x for directoriesytarAn f with all default values except for the file name and type. It uses the portable USTAR/POSIX format (see S).=You can use this as a basis and override specific fields, eg: 2(emptyEntry name HardLink) { linkTarget = target }ztarA tar f for a file.Entry fields such as file permissions and ownership have default values.You can use this as a basis and override specific fields. For example if you need an executable file you could use: :(fileEntry name content) { fileMode = executableFileMode }{tarA tar f for a symbolic link.|tar ?https://www.gnu.org/software/tar/manual/html_node/Standard.html GNU extension* to store a filepath too long to fit into h as d 'L' with the full filepath as i?. The next entry must contain the actual data with truncated h.See https://stackoverflow.com/questions/2078778/what-exactly-is-the-gnu-tar-longlink-trickWhat exactly is the GNU tar ..@LongLink "trick"?}tar ?https://www.gnu.org/software/tar/manual/html_node/Standard.html GNU extension- to store a link target too long to fit into h as d 'K' with the full filepath as i?. The next entry must contain the actual data with truncated h.~tarA tar f for a directory.Entry fields such as file permissions and ownership have default values.tar Convert a O to a native . The native  will use the native directory separator but it is not otherwise checked for validity or sanity. In particular:?The tar path may be invalid as a native path, eg the file name "nul" is not valid on Windows.4The tar path may be an absolute path or may contain ".." components. For security reasons this should not usually be allowed, but it is your responsibility to check for these conditions (e.g., using  ).tar Convert a O to a Unix/Posix .The difference compared to  is that it always returns a Unix style path irrespective of the current operating system.This is useful to check how a O would be interpreted on a specific operating system, eg to perform portability checks.tar Convert a O to a Windows . The only difference compared to  is that it always returns a Windows style path irrespective of the current operating system.This is useful to check how a O would be interpreted on a specific operating system, eg to perform portability checks.tarConvert a native  to a O.The conversion may fail if the  is empty or too long. Use  for a structured output.tarConvert a native  to a O/. Directory paths must always have a trailing /, this is not checked.tarTake a sanitised path, split on directory separators and try to pack it into the 155 + 100 tar file name format.The strategy is this: take the name-directory components in reverse order and try to fit as many components into the 100 long name area as possible. If all the remaining components fit in the 155 name area then we win.tarConvert a native  to a tar I. string is longer than 100 characters or if it contains non-portable characters.tarConvert a native + to a unix filepath suitable for using as I/. Does not error if longer than 100 characters.tarConvert a tar I to a native .tarConvert a tar I to a Unix/POSIX  ('/' path separators).tarConvert a tar I to a Windows  ('\\' path separators).tar$Convert a unix FilePath to a native .tar%Convert a unix FilePath to a Windows .tarThis is like the standard  function on lists, but for D. It includes failure as an extra possibility that the stepper function may return.It can be used to generate D from some other type. For example it is used internally to lazily unfold entries from a .tarThis is like the standard  function on lists, but for D. Compared to  it takes an extra function to account for the possibility of failure.This is used to consume a sequence of entries. For example it could be used to scan a tarball for problems or to collect an index of the contents.tarA -like function on Entries. It either returns the final accumulator result, or the failure along with the intermediate accumulator value.tarThis is like the standard  function on lists, but for D. It includes failure as a extra possible outcome of the mapping function.If your mapping function cannot fail it may be more convenient to use tarLike - but the mapping function itself cannot fail.tartartartarIs the path for a directory? This is needed because for directories a O must always use a trailing /.tarFunction to apply to each entrytarInput sequenceDEFGHIJKLMNOPQRSTUVXWYZ[\^_]`abcdefgihjklmnopqrstuvwxyz{|}~fgihjklmet\^_]`abcd[snUVXWYZroqpQRSTy|}z{~uvwxOPKLMNIJEFGHDF5(c) 2007 Bjorn Bringert, 2008 Andrea Vezzosi, 2008-2009 Duncan Coutts, 2011 Max BolingbrokeBSD3duncan@community.haskell.orgportable Safe-Inferred64tar:Errors that can be encountered when parsing a Tar archive.tarConvert a data stream in the tar file format into an internal data structure. Decoding errors are reported by the H constructor of the D type.The conversion is done lazily.   Safe-Inferred7tarErrors raised by .tar Two adjacent d 'K' nodes.tar Two adjacent d 'L' nodes.tard 'K' node is not followed by a _ / `.tar(Translate high-level entries with POSIX s for files and symlinks into entries suitable for serialization by emitting additional d 'K' and d 'L' nodes.Input ,s must be POSIX file names, not native ones.tarTranslate low-level entries (usually freshly deserialized) into high-level entries with POSIX 6s for files and symlinks by parsing and eliminating d 'K' and d 'L' nodes. Resolved .s are still POSIX file names, not native ones.tar(LongLink entry, actual entry)tar&(LongLink symlink entry, actual entry)(c) 2010-2015 Duncan CouttsBSD3duncan@community.haskell.orgportable Safe-Inferred6Ptar=The intermediate type used for incremental construction of a .tar!An offset within a tar file. Use ,  or .:This is actually a tar "record" number, not a byte offset.tarThe result of  in a . It can either be a file directly, or a directory entry containing further entries (and all subdirectories recursively). Note that the subtrees are constructed lazily, so it's cheaper if you don't look at them.tar&An index of the entries in a tar file.This index type is designed to be quite compact and suitable to store either on disk or in memory.tar Look up a given filepath in the . It may return a  containing the  of the file within the tar file, or if the filepath identifies a directory then it returns a 5 containing the list of files within that directory. Given the , you can then use one of the I/O operations: to read the whole entry;2 to read just the file metadata (e.g. its length);tar4All the files in the index with their corresponding s.Note that the files are in no special order. If you intend to read all or most files then is is recommended to sort by the .tarBuild a  from a sequence of tar D. The D! are assumed to start at offset 0 within a file.tarThe initial empty .tar Add the next f into the .tarUse this function if you want to skip some entries and not add them to the final .tarFinish accumulating f# information and build the compact  lookup structure.tarThis is the offset immediately following the entry most recently added to the . You might use this if you need to know the offsets but don't want to use the  lookup structure. Use with  . See also .tarThis is the offset immediately following the last entry in the tar file. This can be useful to append further entries into the tar file. Use with , or just use  directly.tarCalculate the  of the next entry, given the size and offset of the current entry.This is much like using  and , but without using an .tar!Resume building an existing indexA  is optimized for a highly compact and efficient in-memory representation. This, however, makes it read-only. If you have an existing  for a large file, and want to add to it, you can translate the  back to an . Be aware that this is a relatively costly operation (linear in the size of the 9), though still faster than starting again from scratch.This is the left inverse to  (modulo ordering).tarReads an entire f at the given  in the tar file. The * must be open for reading and be seekable.This reads the whole entry into memory strictly, not incrementally. For more control, use * and then read the entry content manually.tarRead the header for a f at the given  in the tar file. The i will contain the correct metadata but an empty file content. The * must be open for reading and be seekable.The  position is advanced to the beginning of the entry content (if any). You must check the i! to see if the entry is of type ]. If it is, the ] gives the content length and you are free to read this much data from the . entry <- Tar.hReadEntryHeader hnd case Tar.entryContent entry of Tar.NormalFile _ size -> do content <- BS.hGet hnd size ...6Of course you don't have to read it all in one go (as  does), you can use any appropriate method to read it incrementally.,In addition to I/O errors, this can throw a  if the offset is wrong, or if the file is not valid tar format.(There is also the lower level operation .tarSet the 6 position to the position corresponding to the given .This position is where the entry metadata can be read. If you already know the entry has a body (and perhaps know it's length), you may wish to seek to the body content directly using .tarSet the  position to the entry content position corresponding to the given .This position is where the entry content can be read using ordinary I/O operations (though you have to know in advance how big the entry content is). This is  only valid if you  already know/ the entry has a body (i.e. is a normal file).tarThis is a low level variant on , that can be used to iterate through a tar file, entry by entry.%It has a few differences compared to :It returns an indication when the end of the tar file is reached.It does not move the 3 position to the beginning of the entry content.It returns the  of the next entry.After this action, the  position is not in any useful place. If you want to skip to the next entry, take the  returned and use # again. Or if having inspected the f header you want to read the entry content (if it has one) then use  on the original input .tarSeek to the end of a tar file, to the position where new entries can be appended, and return that .If you have a valid  for this tar file then you should supply it because it allows seeking directly to the correct location.If you do not have an index, then this becomes an expensive linear operation because we have to read each tar entry header from the beginning to find the location immediately after the last entry (this is because tar files have a variable length trailer and we cannot reliably find that by starting at the end). In this mode, it will fail with an exception if the file is not in fact in the tar format.tarThe  is compact in memory, and it has a similarly compact external representation.tar-Read the external representation back into a .(c) 2010-2015 Duncan CouttsBSD3duncan@community.haskell.orgportable Safe-InferredQz(c) 2008-2012 Duncan Coutts 2011 Max BolingbrokeBSD3duncan@community.haskell.orgportable Safe-Inferred(6[ tar9The name of a platform that portability issues arise fromtar%Portability problems in a tar archivetarAn error that occurs if a tar file is a "tar bomb" that would extract files outside of the intended directory.tarErrors arising from tar file names being in some way invalid or dangeroustartarThis function checks a sequence of tar entries for file name security problems. It checks that:file paths are not absolute.file paths do not refer outside of the archivefile names are validThese checks are from the perspective of the current OS. That means we check for "C:blah" files on Windows and "/blah" files on Unix. For archive entry types ` and _ the same checks are done for the link target. A failure in any entry terminates the sequence of entries with an error.tar Worker of .tarThis function checks a sequence of tar entries for being a "tar bomb". This means that the tar file does not follow the standard convention that all entries are within a single subdirectory, e.g. a file "foo.tar" would usually have all entries within the "foo/" subdirectory.Given the expected subdirectory, this function checks all entries are within that subdirectroy.2Note: This check must be used in conjunction with  (or ).tar Worker of .tarThis function checks a sequence of tar entries for a number of portability issues. It will complain if:The old "Unix V7" or "gnu" formats are used. For maximum portability only the POSIX standard "ustar" format should be used.A non-portable entry type is used. Only ordinary files, hard links, symlinks and directories are portable. Device files, pipes and others are not portable between all common operating systems.Non-ASCII characters are used in file names. There is no agreed portable convention for Unicode or other extended character sets in file names in tar archives.File names that would not be portable to both Unix and Windows. This check includes characters that are valid in both systems and the '/' vs '\' directory separator conventions.tar Worker of .tarPath inside archive.tarExpected top directory. (c) 2007 Bjorn Bringert, 2008 Andrea Vezzosi, 2008-2009, 2012, 2016 Duncan CouttsBSD3duncan@community.haskell.orgportable Safe-InferredhtarCreates a tar archive from a list of directory or files. Any directories specified will have their contents included recursively. Paths in the archive will be relative to the given base directory.This is a portable implementation of packing suitable for portable archives. In particular it only constructs ], ^ and _ entries. Hard links are treated like ordinary files. Special files like FIFOs (named pipes), sockets or device files will cause problems.An exception will be thrown for any file names that are too long to represent as a O.This function returns results lazily. Subdirectories are scanned and files are read one by one as the list of entries is consumed.tarLike , but allows to specify additional sanity/security checks on the input filenames. This is useful if you know which check will be used on client side in  / .tar3Pack paths while accounting for overlong filepaths.tarConstruct a tar f based on a local file.This sets the entry size, the data contained in the file and the file's modification time. If the file is executable then that information is also preserved. File ownership and detailed permissions are not preserved.!The file contents is read lazily.tarConstruct a tar f3 based on a local directory (but not its contents).The only attribute of the directory that is used is its modification time. Directory ownership and detailed permissions are not preserved.tarConstruct a tar f based on a local symlink.-This automatically checks symlink safety via .tar&This is a utility function, much like . The difference is that it includes the contents of subdirectories.The paths returned are all relative to the top directory. Directory paths are distinguishable by having a trailing path separator (see ).All directories are listed before the files that they contain. Amongst the contents of a directory, subdirectories are listed after normal files. The overall result is that files within a directory will be together in a single contiguous group. This tends to improve file layout and IO performance when creating or extracting tar archives.This function returns results lazily. Subdirectories are not scanned until the files entries in the parent directory have been consumed. If the source directory structure changes before the result is used, the behaviour is undefined.tarBase directorytar7Files and directories to pack, relative to the base dirtarBase directorytar7Files and directories to pack, relative to the base dirtar,Full path to find the file on the local disktarPath to use for the tar f in the archivetar,Full path to find the file on the local disktarPath to use for the tar f in the archivetar,Full path to find the file on the local disktarPath to use for the tar f in the archive||(c) 2007 Bjorn Bringert, 2008 Andrea Vezzosi, 2008-2009 Duncan CouttsBSD3duncan@community.haskell.orgportable Safe-Inferredi|:IOQRSTUVXWYZ[\^_]`abcdefgihjklmnopqrstuwxyz|}~:fgihjklmet\^_]`abcd[UVXWYZsnrqpoQRSTyz~|}uwxOI (c) 2008-2012 Duncan Coutts 2011 Max BolingbrokeBSD3duncan@community.haskell.orgportable Safe-Inferredj (c) 2007 Bjorn Bringert, 2008 Andrea Vezzosi, 2008-2009, 2012, 2016 Duncan CouttsBSD3duncan@community.haskell.orgportable Safe-Inferred(q,tarCreate local files and directories based on the entries of a tar archive.This is a portable implementation of unpacking suitable for portable archives. It handles ] and ^( entries and has simulated support for _ and ` entries. Links are implemented by copying the target file. This therefore works on Windows as well as Unix. All other entry types are ignored, that is they are not unpacked and no exception is raised.If the D ends in an error then it is raised an an exception. Any files or directories that have been unpacked before the error was encountered will not be deleted. For this reason you may want to unpack into an empty directory so that you can easily clean up if unpacking fails part-way.:On its own, this function only checks for security (using ). Use  if you need more checks.tarLike 3, but run custom sanity/security checks instead of . For example, unpackAndCheck (\x -> SomeException <$> checkEntryPortability x <|> SomeException <$> checkEntrySecurity x) dir entriestar?Recursively copy the contents of one directory to another path.#This is a rip-off of Cabal library.tarBase directorytarEntries to upacktar,Checks to run on each entry before unpackingtarBase directorytarEntries to upack (c) 2007 Bjorn Bringert, 2008 Andrea Vezzosi, 2008-2009 Duncan CouttsBSD3duncan@community.haskell.orgportable Safe-Inferredr~tarCreate the external representation of a tar archive by serialising a list of tar entries.The conversion is done lazily. (c) 2007 Bjorn Bringert, 2008 Andrea Vezzosi, 2008-2012 Duncan CouttsBSD3duncan@community.haskell.orgportable Safe-Inferred~^tar Create a new ".tar" file from a directory of files.)It is equivalent to calling the standard tar program like so: #$ tar -f tarball.tar -C base -c dirThis assumes a directory  ./base/dir with files inside, eg ./base/dir/foo.txt. The file names inside the resulting tar file will be relative to dir, eg  dir/foo.txt.This is a high level "all in one" operation. Since you may need variations on this function it is instructive to see how it is written. It is just: 4BS.writeFile tar . Tar.write =<< Tar.pack base pathsNotes:The files and directories must not change during this operation or the result is not well defined.The intention of this function is to create tarballs that are portable between systems. It is not suitable for doing file system backups because file ownership and permissions are not fully preserved. File ownership is not preserved at all. File permissions are set to simple portable values: rw-r--r-- for normal files rwxr-xr-x for executable files rwxr-xr-x for directoriestar%Extract all the files contained in a ".tar" file.)It is equivalent to calling the standard tar program like so: $ tar -x -f tarball.tar -C dirSo for example if the  tarball.tar file contains  foo/bar.txt then this will extract it to dir/foo/bar.txt.This is a high level "all in one" operation. Since you may need variations on this function it is instructive to see how it is written. It is just: -Tar.unpack dir . Tar.read =<< BS.readFile tarNotes:Extracting can fail for a number of reasons. The tarball may be incorrectly formatted. There may be IO or permission errors. In such cases an exception will be thrown and extraction will not continue.Since the extraction may fail part way through it is not atomic. For this reason you may want to extract into an empty directory and, if the extraction fails, recursively delete the directory.Security: only files inside the target directory will be written. Tarballs containing entries that point outside of the tarball (either absolute paths or relative paths) will be caught and an exception will be thrown.tarAppend new entries to a ".tar" file from a directory of files.This is much like , except that all the entries are added to the end of an existing tar file. Or if the file does not already exists then it behaves the same as .tar!Path of the ".tar" file to write.tarBase directorytar6Files and directories to archive, relative to base dirtarDestination directorytarTarballtar!Path of the ".tar" file to write.tarBase directorytar6Files and directories to archive, relative to base dir0DEFGH[\^_]`abcdefit0feti\^_]`abcd[EFGHD  !"#$%&'()*+,-./0123456789:;<=>?@@&AB%'()*+-.CDEFGHIJKLMNOOPQRSTTUVWXYYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~&$'*+-./              /tar-0.6.0.0-8gZENASsLVlGRQvUWQRGuQ-tar-internalCodec.Archive.Tar.Index.IntTrie#Codec.Archive.Tar.Index.StringTableCodec.Archive.Tar.PackAsciiCodec.Archive.Tar.TypesCodec.Archive.Tar.ReadCodec.Archive.Tar.LongNames Codec.Archive.Tar.Index.Internal Codec.Archive.Tar.Check.InternalCodec.Archive.Tar.PackCodec.Archive.Tar.UnpackCodec.Archive.Tar.WriteCodec.Archive.TarCodec.Archive.Tar.CheckcheckEntrySecurity Data.ListunfoldrCodec.Archive.Tar.IndexCodec.Tar.CheckunpackunpackAndCheckCodec.Archive.Tar.EntryTrieNodeTrieLeafIntTrieBuilder Completions TrieLookupEntryValueunValueKeyunKeyIntTrietagLeaftagNodecompletionsFromtoList constructlookupemptyinsertinsertsfinalise unfinalise flattenTrie serialise serialiseSize deserialise$fShowTrieNode $fEqTrieNode$fShowIntTrieBuilder$fEqIntTrieBuilder$fEqTrieLookup$fOrdTrieLookup$fShowTrieLookup $fEqValue $fOrdValue $fShowValue$fEqKey$fOrdKey $fShowKey $fEqIntTrie $fShowIntTrieStringTableBuilder StringTableindex'index deserialiseV1 deserialiseV2$fEqStringTable$fEqStringTableBuilder$fShowStringTableBuilder$fShowStringTable packAsciiEntries GenEntriesNextDoneFail LinkTargetToTarPathResult FileNameEmpty FileNameOKFileNameTooLongTarPathFormatV7Format UstarFormat GnuFormat Ownership ownerName groupNameownerIdgroupId EntryContentGenEntryContent NormalFile Directory SymbolicLinkHardLinkCharacterDevice BlockDevice NamedPipeOtherEntryTypeGenEntry entryTarPath entryContententryPermissionsentryOwnership entryTime entryFormat PermissionsTypeCodeDevMinorDevMajor EpochTimeFileSize entryPathordinaryFilePermissionssymbolicLinkPermissionexecutableFilePermissionsdirectoryPermissions simpleEntry fileEntry symlinkEntry longLinkEntrylongSymLinkEntrydirectoryEntry fromTarPathfromTarPathToPosixPathfromTarPathToWindowsPath toTarPath toTarPath' toLinkTargetfromLinkTargetfromLinkTargetToPosixPathfromLinkTargetToWindowsPathfromFilePathToNativefromFilePathToWindowsPath unfoldEntries foldEntries foldlEntries mapEntriesmapEntriesNoFail$fNFDataGenEntryContent$fNFDataOwnership$fNFDataGenEntry $fShowTarPath$fNFDataTarPath$fNFDataLinkTarget$fExceptionLinkTargetException$fNFDataGenEntries$fMonoidGenEntries$fSemigroupGenEntries$fEqGenEntries$fShowGenEntries$fFunctorGenEntries$fFoldableGenEntries$fTraversableGenEntries$fShowLinkTargetException$fEqLinkTarget$fOrdLinkTarget$fShowLinkTarget $fEqTarPath $fOrdTarPath $fEqGenEntry$fShowGenEntry $fEqFormat $fOrdFormat $fShowFormat $fEqOwnership$fOrdOwnership$fShowOwnership$fEqGenEntryContent$fOrdGenEntryContent$fShowGenEntryContent FormatErrorTruncatedArchive ShortTrailer BadTrailer TrailingJunkChecksumIncorrect NotTarFormatUnrecognisedTarFormatHeaderBadNumericEncodingread$fNFDataFormatError$fExceptionFormatError$fEqFormatError$fShowFormatErrorDecodeLongNamesErrorTwoTypeKEntriesTwoTypeLEntriesNoLinkEntryAfterTypeKEntryencodeLongNamesdecodeLongNames$fExceptionDecodeLongNamesError$fEqDecodeLongNamesError$fOrdDecodeLongNamesError$fShowDecodeLongNamesError IndexBuilderTarEntryOffsetPathComponentId TarIndexEntry TarFileEntryTarDirTarIndextoComponentIdsbuild addNextEntry skipNextEntryindexNextEntryOffsetindexEndEntryOffsetnextEntryOffset hReadEntryhReadEntryHeaderhSeekEntryOffsethSeekEntryContentOffsethReadEntryHeaderOrEofhSeekEndEntryOffset serialiseLBS$fNFDataTarIndex$fNFDataIndexBuilder$fEqIndexBuilder$fShowIndexBuilder $fEqTarIndex$fShowTarIndex$fShowTarIndexEntry$fEqPathComponentId$fOrdPathComponentId$fEnumPathComponentId$fShowPathComponentIdPortabilityPlatformPortabilityErrorNonPortableFormatNonPortableFileTypeNonPortableEntryNameCharNonPortableFileName TarBombError FileNameErrorInvalidFileNameAbsoluteFileNameUnsafeLinkTarget checkSecurity checkTarbombcheckEntryTarbombcheckPortabilitycheckEntryPortability$fExceptionFileNameError$fShowFileNameError$fShowTarBombError$fExceptionTarBombError$fShowPortabilityError$fExceptionPortabilityErrorpack packAndCheck packFileEntrypackDirectoryEntrypackSymlinkEntrygetDirectoryContentsRecursivewritecreateextractappendbaseGHC.IOFilePathGHC.BaseMonoid splitLongPath toLinkTarget'bytestring-0.11.3.1Data.ByteString.Lazy.Internal ByteString Data.Foldablefoldrfoldlmap encodeTarPathencodeLinkTargetGHC.IO.Handle.TypesHandle packPathsdirectory-1.3.6.2System.Directory listDirectoryfilepath-1.4.2.2System.FilePath.PosixhasTrailingPathSeparatorcopyDirectoryRecursive