PyFoxFile 0.20.8__py3-none-any.whl → 0.21.2__py3-none-any.whl

pyfoxfile.py

@@ -14,7 +14,7 @@
     Copyright 2018-2024 Game Maker 2k - http://intdb.sourceforge.net/
     Copyright 2018-2024 Kazuki Przyborowski - https://github.com/KazukiPrzyborowski
 
-    $FileInfo: pyfoxfile.py - Last Update: 9/16/2025 Ver. 0.20.8 RC 1 - Author: cooldude2k $
+    $FileInfo: pyfoxfile.py - Last Update: 8/24/2025 Ver. 0.21.2 RC 1 - Author: cooldude2k $
 '''
 
 from __future__ import absolute_import, division, print_function, unicode_literals, generators, with_statement, nested_scopes
@@ -370,6 +370,10 @@ if(__include_defaults__):
         __file_format_multi_dict__.update( { 'きつねファイル': {'format_name': "KitsuneFairu", 'format_magic': "きつねファイル", 'format_len': 21, 'format_hex': "e3818de381a4e381ade38395e382a1e382a4e383ab", 'format_delimiter': "\x00", 'format_ver': "001", 'new_style': True, 'use_advanced_list': True, 'use_alt_inode': False, 'format_extension': ".きつね" } } )
     if("狐ファイル" not in __file_format_multi_dict__):
         __file_format_multi_dict__.update( { '狐ファイル': {'format_name': "KitsuneFairu", 'format_magic': "狐ファイル", 'format_len': 15, 'format_hex': "e78b90e38395e382a1e382a4e383ab", 'format_delimiter': "\x00", 'format_ver': "001", 'new_style': True, 'use_advanced_list': True, 'use_alt_inode': False, 'format_extension': ".狐" } } )
+    if("狐狸文件" not in __file_format_multi_dict__):
+        __file_format_multi_dict__.update( { '狐狸文件': {'format_name': "HúlíWénjiàn", 'format_magic': "狐狸文件", 'format_len': 12, 'format_hex': "ec97acec9ab0ed8c8cec9dbc", 'format_delimiter': "\x00", 'format_ver': "001", 'new_style': True, 'use_advanced_list': True, 'use_alt_inode': False, 'format_extension': ".狐狸" } } )
+    if("여우파일" not in __file_format_multi_dict__):
+        __file_format_multi_dict__.update( { '여우파일': {'format_name': "YeouPa-il", 'format_magic': "여우파일", 'format_len': 12, 'format_hex': "ec97acec9ab0ed8c8cec9dbc", 'format_delimiter': "\x00", 'format_ver': "001", 'new_style': True, 'use_advanced_list': True, 'use_alt_inode': False, 'format_extension': ".여우" } } )
 if(__file_format_default__ not in __file_format_multi_dict__):
     __file_format_default__ = next(iter(__file_format_multi_dict__))
 __file_format_name__ = __file_format_multi_dict__[__file_format_default__]['format_name']
@@ -385,12 +389,12 @@ __file_format_extension__ = __file_format_multi_dict__[__file_format_default__][
 __file_format_dict__ = __file_format_multi_dict__[__file_format_default__]
 __project__ = __program_name__
 __project_url__ = "https://github.com/GameMaker2k/PyFoxFile"
-__version_info__ = (0, 20, 8, "RC 1", 1)
-__version_date_info__ = (2025, 9, 16, "RC 1", 1)
+__version_info__ = (0, 21, 2, "RC 1", 1)
+__version_date_info__ = (2025, 9, 24, "RC 1", 1)
 __version_date__ = str(__version_date_info__[0]) + "." + str(
     __version_date_info__[1]).zfill(2) + "." + str(__version_date_info__[2]).zfill(2)
 __revision__ = __version_info__[3]
-__revision_id__ = "$Id: c24bcebed9f90311395ef150d337a5669849d131 $"
+__revision_id__ = "$Id: c85d5aa829f172404f285788e6b35f73a35767c2 $"
 if(__version_info__[4] is not None):
     __version_date_plusrc__ = __version_date__ + \
         "-" + str(__version_date_info__[4])
@@ -1953,15 +1957,15 @@ def ReadFileHeaderDataWithContent(fp, listonly=False, uncompress=True, skipcheck
         HeaderOut = ReadFileHeaderDataWoSize(fp, delimiter)
     if(len(HeaderOut) == 0):
         return False
-    if(re.findall("^[.|/]", HeaderOut[3])):
-        fname = HeaderOut[3]
+    if(re.findall("^[.|/]", HeaderOut[5])):
+        fname = HeaderOut[5]
     else:
-        fname = "./"+HeaderOut[3]
+        fname = "./"+HeaderOut[5]
     fcs = HeaderOut[-2].lower()
     fccs = HeaderOut[-1].lower()
-    fsize = int(HeaderOut[5], 16)
-    fcompression = HeaderOut[12]
-    fcsize = int(HeaderOut[13], 16)
+    fsize = int(HeaderOut[7], 16)
+    fcompression = HeaderOut[14]
+    fcsize = int(HeaderOut[15], 16)
     fseeknextfile = HeaderOut[26]
     fjsontype = HeaderOut[27]
     fjsonlen = int(HeaderOut[28], 16)
@@ -2014,6 +2018,7 @@ def ReadFileHeaderDataWithContent(fp, listonly=False, uncompress=True, skipcheck
     fcontents.seek(0, 0)
     newfccs = GetFileChecksum(
         fcontents.read(), HeaderOut[-3].lower(), False, formatspecs)
+    fcontents.seek(0, 0)
     if(fccs != newfccs and not skipchecksum and not listonly):
         VerbosePrintOut("File Content Checksum Error with file " +
                         fname + " at offset " + str(fcontentstart))
@@ -2026,7 +2031,7 @@ def ReadFileHeaderDataWithContent(fp, listonly=False, uncompress=True, skipcheck
         if(uncompress):
             cfcontents = UncompressFileAlt(fcontents, formatspecs)
             cfcontents.seek(0, 0)
-            cfcontents.seek(0, 0)
+            fcontents = BytesIO()
             shutil.copyfileobj(cfcontents, fcontents)
             cfcontents.close()
             fcontents.seek(0, 0)
@@ -2118,6 +2123,7 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
                 fextrafieldslist = json.loads(fextrafieldslist[0])
             except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                 pass
+    fjstart = fp.tell()
     if(fjsontype=="json"):
         fjsoncontent = {}
         fprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
@@ -2145,11 +2151,11 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
         fjsoncontent = ReadFileHeaderData(flisttmp, fjsonlen, delimiter)
         flisttmp.close()
         fjsonrawcontent = fjsoncontent
-        if(outfjsonlen==1):
+        if(fjsonlen==1):
             try:
                 fjsonrawcontent = base64.b64decode(fjsoncontent[0]).decode("UTF-8")
                 fjsoncontent = json.loads(base64.b64decode(fjsoncontent[0]).decode("UTF-8"))
-                outfjsonlen = len(fjsoncontent)
+                fjsonlen = len(fjsoncontent)
             except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                 try:
                     fjsonrawcontent = fjsoncontent[0]
@@ -2157,6 +2163,7 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
                 except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                     pass
     fp.seek(len(delimiter), 1)
+    fjend = fp.tell() - 1
     jsonfcs = GetFileChecksum(fprejsoncontent, fjsonchecksumtype, True, formatspecs)
     if(jsonfcs != fjsonchecksum and not skipchecksum):
         VerbosePrintOut("File JSON Data Checksum Error with file " +
@@ -2191,6 +2198,7 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
     fcontents.seek(0, 0)
     newfccs = GetFileChecksum(
         fcontents.read(), HeaderOut[-3].lower(), False, formatspecs)
+    fcontents.seek(0, 0)
     if(fccs != newfccs and not skipchecksum and not listonly):
         VerbosePrintOut("File Content Checksum Error with file " +
                         fname + " at offset " + str(fcontentstart))
@@ -2232,7 +2240,7 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
     if(not contentasfile):
         fcontents = fcontents.read()
     outlist = {'fheadersize': fheadsize, 'fhstart': fheaderstart, 'fhend': fhend, 'ftype': ftype, 'fencoding': fencoding, 'fcencoding': fcencoding, 'fname': fname, 'fbasedir': fbasedir, 'flinkname': flinkname, 'fsize': fsize, 'fatime': fatime, 'fmtime': fmtime, 'fctime': fctime, 'fbtime': fbtime, 'fmode': fmode, 'fchmode': fchmode, 'ftypemod': ftypemod, 'fwinattributes': fwinattributes, 'fcompression': fcompression, 'fcsize': fcsize, 'fuid': fuid, 'funame': funame, 'fgid': fgid, 'fgname': fgname, 'finode': finode, 'flinkcount': flinkcount,
-               'fdev': fdev, 'fminor': fdev_minor, 'fmajor': fdev_major, 'fseeknextfile': fseeknextfile, 'fheaderchecksumtype': HeaderOut[-4], 'fjsonchecksumtype': outfjsonchecksumtype, 'fcontentchecksumtype': HeaderOut[-3], 'fnumfields': fnumfields + 2, 'frawheader': HeaderOut, 'fextrafields': fextrafields, 'fextrafieldsize': fextrasize, 'fextradata': fextrafieldslist, 'fjsontype': fjsontype, 'fjsonlen': fjsonlen, 'fjsonsize': fjsonsize, 'fjsonrawdata': fjsonrawcontent, 'fjsondata': fjsoncontent, 'fjstart': outfjstart, 'fjend': outfjend, 'fheaderchecksum': fcs, 'fjsonchecksum': outfjsonchecksum, 'fcontentchecksum': fccs, 'fhascontents': pyhascontents, 'fcontentstart': fcontentstart, 'fcontentend': fcontentend, 'fcontentasfile': contentasfile, 'fcontents': fcontents}
+               'fdev': fdev, 'fminor': fdev_minor, 'fmajor': fdev_major, 'fseeknextfile': fseeknextfile, 'fheaderchecksumtype': HeaderOut[-4], 'fjsonchecksumtype': fjsonchecksumtype, 'fcontentchecksumtype': HeaderOut[-3], 'fnumfields': fnumfields + 2, 'frawheader': HeaderOut, 'fextrafields': fextrafields, 'fextrafieldsize': fextrasize, 'fextradata': fextrafieldslist, 'fjsontype': fjsontype, 'fjsonlen': fjsonlen, 'fjsonsize': fjsonsize, 'fjsonrawdata': fjsonrawcontent, 'fjsondata': fjsoncontent, 'fjstart': fjstart, 'fjend': fjend, 'fheaderchecksum': fcs, 'fjsonchecksum': fjsonchecksum, 'fcontentchecksum': fccs, 'fhascontents': pyhascontents, 'fcontentstart': fcontentstart, 'fcontentend': fcontentend, 'fcontentasfile': contentasfile, 'fcontents': fcontents}
     return outlist
 
 
@@ -2329,11 +2337,11 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
         fjsoncontent = ReadFileHeaderData(flisttmp, fjsonlen, delimiter)
         flisttmp.close()
         fjsonrawcontent = fjsoncontent
-        if(fextrafields==1):
+        if(fjsonlen==1):
             try:
                 fjsonrawcontent = base64.b64decode(fjsoncontent[0]).decode("UTF-8")
                 fjsoncontent = json.loads(base64.b64decode(fjsoncontent[0]).decode("UTF-8"))
-                fextrafields = len(fjsoncontent)
+                fjsonlen = len(fjsoncontent)
             except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                 try:
                     fjsonrawcontent = fjsoncontent[0]
@@ -2543,11 +2551,11 @@ def ReadFileDataWithContentToArray(fp, seekstart=0, seekend=0, listonly=False, c
     formversions = re.search('(.*?)(\\d+)', formstring).groups()
     fcompresstype = ""
     outlist = {'fnumfiles': fnumfiles, 'fformat': formversions[0], 'fcompression': fcompresstype, 'fencoding': fhencoding, 'fversion': formversions[1], 'fostype': fostype, 'fheadersize': fheadsize, 'fsize': CatSizeEnd, 'fnumfields': fnumfields + 2, 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'frawheader': [formstring] + inheader, 'fextrafields': fnumextrafields, 'fextrafieldsize': fnumextrafieldsize, 'fextradata': fextrafieldslist, 'ffilelist': []}
-    if(seekstart < 0 and seekstart > fnumfiles):
+    if (seekstart < 0) or (seekstart > fnumfiles):
         seekstart = 0
-    if(seekend == 0 or seekend > fnumfiles and seekend < seekstart):
+    if (seekend == 0) or (seekend > fnumfiles) or (seekend < seekstart):
         seekend = fnumfiles
-    elif(seekend < 0 and abs(seekend) <= fnumfiles and abs(seekend) >= seekstart):
+    elif (seekend < 0) and (abs(seekend) <= fnumfiles) and (abs(seekend) >= seekstart):
         seekend = fnumfiles - abs(seekend)
     if(seekstart > 0):
         il = 0
@@ -2558,14 +2566,18 @@ def ReadFileDataWithContentToArray(fp, seekstart=0, seekend=0, listonly=False, c
             if(len(preheaderdata) == 0):
                 break
             prefsize = int(preheaderdata[5], 16)
+            if(re.findall("^[.|/]", preheaderdata[5])):
+                prefname = preheaderdata[5]
+            else:
+                prefname = "./"+preheaderdata[5]
             prefseeknextfile = preheaderdata[26]
             prefjsonlen = int(preheaderdata[28], 16)
             prefjsonsize = int(preheaderdata[29], 16)
             prefjsonchecksumtype = preheaderdata[30]
             prefjsonchecksum = preheaderdata[31]
-            prefprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
+            prejsoncontent = fp.read(prefjsonsize).decode("UTF-8")
             fp.seek(len(delimiter), 1)
-            prejsonfcs = GetFileChecksum(fprejsoncontent, prefjsonchecksumtype, True, formatspecs)
+            prejsonfcs = GetFileChecksum(prejsoncontent, prefjsonchecksumtype, True, formatspecs)
             if(prejsonfcs != prefjsonchecksum and not skipchecksum):
                 VerbosePrintOut("File JSON Data Checksum Error with file " +
                                 prefname + " at offset " + str(prefhstart))
@@ -2575,7 +2587,7 @@ def ReadFileDataWithContentToArray(fp, seekstart=0, seekend=0, listonly=False, c
                 preheaderdata[:-2], preheaderdata[-4].lower(), True, formatspecs)
             prefcs = preheaderdata[-2]
             if(prefcs != prenewfcs and not skipchecksum):
-                VVerbosePrintOut("File Header Checksum Error with file " +
+                VerbosePrintOut("File Header Checksum Error with file " +
                                  prefname + " at offset " + str(prefhstart))
                 VerbosePrintOut("'" + prefcs + "' != " +
                                 "'" + prenewfcs + "'")
@@ -2698,11 +2710,11 @@ def ReadFileDataWithContentToList(fp, seekstart=0, seekend=0, listonly=False, co
         return False
     formversions = re.search('(.*?)(\\d+)', formstring).groups()
     outlist = []
-    if(seekstart < 0 and seekstart > fnumfiles):
+    if (seekstart < 0) or (seekstart > fnumfiles):
         seekstart = 0
-    if(seekend == 0 or seekend > fnumfiles and seekend < seekstart):
+    if (seekend == 0) or (seekend > fnumfiles) or (seekend < seekstart):
         seekend = fnumfiles
-    elif(seekend < 0 and abs(seekend) <= fnumfiles and abs(seekend) >= seekstart):
+    elif (seekend < 0) and (abs(seekend) <= fnumfiles) and (abs(seekend) >= seekstart):
         seekend = fnumfiles - abs(seekend)
     if(seekstart > 0):
         il = 0
@@ -2717,16 +2729,20 @@ def ReadFileDataWithContentToList(fp, seekstart=0, seekend=0, listonly=False, co
             if(len(preheaderdata) == 0):
                 break
             prefsize = int(preheaderdata[5], 16)
-            prefcompression = preheaderdata[12]
-            prefcsize = int(preheaderdata[13], 16)
-            prefseeknextfile = HeaderOut[26]
+            if(re.findall("^[.|/]", preheaderdata[5])):
+                prefname = preheaderdata[5]
+            else:
+                prefname = "./"+preheaderdata[5]
+            prefcompression = preheaderdata[14]
+            prefcsize = int(preheaderdata[15], 16)
+            prefseeknextfile = preheaderdata[26]
             prefjsonlen = int(preheaderdata[28], 16)
             prefjsonsize = int(preheaderdata[29], 16)
             prefjsonchecksumtype = preheaderdata[30]
             prefjsonchecksum = preheaderdata[31]
             prefprejsoncontent = fp.read(prefjsonsize).decode("UTF-8")
             fp.seek(len(delimiter), 1)
-            prejsonfcs = GetFileChecksum(fprejsoncontent, prefjsonchecksumtype, True, formatspecs)
+            prejsonfcs = GetFileChecksum(prefprejsoncontent, prefjsonchecksumtype, True, formatspecs)
             if(prejsonfcs != prefjsonchecksum and not skipchecksum):
                 VerbosePrintOut("File JSON Data Checksum Error with file " +
                                 prefname + " at offset " + str(prefhstart))
@@ -2813,13 +2829,13 @@ def ReadInFileWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0,
         fp = UncompressFileAlt(fp, formatspecs)
         checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-            return TarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
+            return TarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
-            return ZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
+            return ZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
-            return RarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
+            return RarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
-            return SevenZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
+            return SevenZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(IsSingleDict(formatspecs) and checkcompressfile != formatspecs['format_magic']):
             return False
         elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
@@ -2929,13 +2945,13 @@ def ReadInFileWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0,
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-            return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, returnfp)
+            return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, True)
         elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
-            return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, returnfp)
+            return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, True)
         elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
-            return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, returnfp)
+            return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, True)
         elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
-            return SevenZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, returnfp)
+            return SevenZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, True)
         elif(IsSingleDict(formatspecs) and checkcompressfile != formatspecs['format_magic']):
             return False
         elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
@@ -2974,7 +2990,7 @@ def ReadInMultipleFileWithContentToArray(infile, fmttype="auto", seekstart=0, se
         infile = [infile]
     outretval = {}
     for curfname in infile:
-        curretfile = outretval.update({curfname: ReadInFileWithContentToArray(curfname, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)})
+        outretval[curfname] = ReadInFileWithContentToArray(curfname, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
     return outretval
 
 def ReadInMultipleFilesWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
@@ -3001,13 +3017,13 @@ def ReadInFileWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0,
         fp = UncompressFileAlt(fp, formatspecs)
         checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-            return TarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
+            return TarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
-            return ZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
+            return ZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
-            return RarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
+            return RarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
-            return SevenZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
+            return SevenZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(IsSingleDict(formatspecs) and checkcompressfile != formatspecs['format_magic']):
             return False
         elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
@@ -3117,13 +3133,13 @@ def ReadInFileWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0,
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-            return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, returnfp)
+            return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, True)
         elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
-            return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, returnfp)
+            return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, True)
         elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
-            return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, returnfp)
+            return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, True)
         elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
-            return SevenZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, returnfp)
+            return SevenZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, seektoend, True)
         elif(IsSingleDict(formatspecs) and checkcompressfile != formatspecs['format_magic']):
             return False
         elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
@@ -3162,7 +3178,7 @@ def ReadInMultipleFileWithContentToList(infile, fmttype="auto", seekstart=0, see
         infile = [infile]
     outretval = {}
     for curfname in infile:
-        curretfile = outretval.update({curfname: ReadInFileWithContentToList(curfname, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)})
+        curretfile[curfname] = ReadInFileWithContentToList(curfname, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
     return outretval
 
 def ReadInMultipleFilesWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
@@ -3207,7 +3223,7 @@ def AppendFileHeader(fp, numfiles, fencoding, extradata=[], checksumtype="crc32"
     tmpoutlist = []
     tmpoutlist.append(extrasizelen)
     tmpoutlist.append(extrafields)
-    fnumfiles = format(int(numfiles), 'x').lower()
+    fnumfiles = format(numfiles, 'x').lower()
     tmpoutlen = 3 + len(tmpoutlist) + len(extradata) + 2
     tmpoutlenhex = format(tmpoutlen, 'x').lower()
     fnumfilesa = AppendNullBytes(
@@ -3261,11 +3277,11 @@ def MakeEmptyFilePointer(fp, fmttype=__file_format_default__, checksumtype="crc3
     return fp
 
 
-def MakeEmptyFoxFilePointer(fp, fmttype=__file_format_default__, checksumtype="crc32", formatspecs=__file_format_multi_dict__):
+def MakeEmptyArchiveFilePointer(fp, fmttype=__file_format_default__, checksumtype="crc32", formatspecs=__file_format_multi_dict__):
     return MakeEmptyFilePointer(fp, fmttype, checksumtype, formatspecs)
 
 
-def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, checksumtype="crc32", formatspecs=__file_format_multi_dict__, returnfp=False):
+def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype="crc32", formatspecs=__file_format_multi_dict__, returnfp=False):
     if(IsNestedDict(formatspecs) and fmttype=="auto" and 
         (outfile != "-" and outfile is not None and not hasattr(outfile, "read") and not hasattr(outfile, "write"))):
         get_in_ext = os.path.splitext(outfile)
@@ -3309,7 +3325,7 @@ def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile
     AppendFileHeader(fp, 0, "UTF-8", [], checksumtype, formatspecs)
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -3333,7 +3349,7 @@ def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile
         return outvar
     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
         upload_file_to_internet_file(fp, outfile)
     if(returnfp):
@@ -3344,8 +3360,8 @@ def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile
         return True
 
 
-def MakeEmptyFoxFile(outfile, compression="auto", compresswholefile=True, compressionlevel=None, checksumtype="crc32", formatspecs=__file_format_dict__, returnfp=False):
-    return MakeEmptyFile(outfile, compression, compresswholefile, compressionlevel, checksumtype, formatspecs, returnfp)
+def MakeEmptyArchiveFile(outfile, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype="crc32", formatspecs=__file_format_dict__, returnfp=False):
+    return MakeEmptyFile(outfile, "auto", compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, formatspecs, returnfp)
 
 
 def AppendFileHeaderWithContent(fp, filevalues=[], extradata=[], jsondata={}, filecontent="", checksumtype=["crc32", "crc32", "crc32"], formatspecs=__file_format_dict__):
@@ -3444,6 +3460,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
     if(verbose):
         logging.basicConfig(format="%(message)s",
                             stream=sys.stdout, level=logging.DEBUG)
+    infilelist = []
     if(infiles == "-"):
         for line in sys.stdin:
             infilelist.append(line.strip())
@@ -3484,7 +3501,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
     inodetoforminode = {}
     numfiles = int(len(GetDirList))
     fnumfiles = format(numfiles, 'x').lower()
-    AppendFileHeader(fp, fnumfiles, "UTF-8", [], checksumtype[0], formatspecs)
+    AppendFileHeader(fp, numfiles, "UTF-8", [], checksumtype[0], formatspecs)
     FullSizeFilesAlt = 0
     for curfname in GetDirList:
         fencoding = "UTF-8"
@@ -3582,7 +3599,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
         elif ftype in data_types:
             fsize = format(int(fstatinfo.st_size), 'x').lower()
         else:
-            fsize = format(int(fstatinfo.st_size)).lower()
+            fsize = format(int(fstatinfo.st_size), 'x').lower()
         fatime = format(int(fstatinfo.st_atime), 'x').lower()
         fmtime = format(int(fstatinfo.st_mtime), 'x').lower()
         fctime = format(int(fstatinfo.st_ctime), 'x').lower()
@@ -3630,11 +3647,14 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
         fcontents = BytesIO()
         chunk_size = 1024
         fcencoding = "UTF-8"
-        if ftype in data_types:
+        curcompression = "none"
+        if not followlink and ftype in data_types:
             with open(fname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
                 fcencoding = GetFileEncoding(fcontents, False)
-                if(not compresswholefile):
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -3649,16 +3669,13 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                             fcontents.seek(0, 0)
                             cfcontents.seek(0, 0)
                             cfcontents = CompressOpenFileAlt(
-                                cfcontents, compressionuselist[ilmin], compressionlevel, formatspecs)
+                                cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, formatspecs)
                             if(cfcontents):
                                 cfcontents.seek(0, 2)
                                 ilcsize.append(cfcontents.tell())
                                 cfcontents.close()
                             else:
-                                try:
-                                    ilcsize.append(sys.maxint)
-                                except AttributeError:
-                                    ilcsize.append(sys.maxsize)
+                                ilcsize.append(float("inf"))
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
@@ -3667,7 +3684,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
-                        cfcontents, curcompression, compressionlevel, formatspecs)
+                        cfcontents, curcompression, compressionlevel, compressionuselist, formatspecs)
                     cfcontents.seek(0, 2)
                     cfsize = cfcontents.tell()
                     if(ucfsize > cfsize):
@@ -3675,13 +3692,16 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                         fcompression = curcompression
                         fcontents.close()
                         fcontents = cfcontents
-        if(followlink and (ftype == 1 or ftype == 2)):
+        elif followlink and (ftype == 1 or ftype == 2):
             if(not os.path.exists(flinkname)):
                 return False
             flstatinfo = os.stat(flinkname)
             with open(flinkname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
-                if(not compresswholefile):
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
+                fcencoding = GetFileEncoding(fcontents, False)
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -3696,16 +3716,13 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                             fcontents.seek(0, 0)
                             cfcontents.seek(0, 0)
                             cfcontents = CompressOpenFileAlt(
-                                cfcontents, compressionuselist[ilmin], compressionlevel, formatspecs)
+                                cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, formatspecs)
                             if(cfcontents):
                                 cfcontents.seek(0, 2)
                                 ilcsize.append(cfcontents.tell())
                                 cfcontents.close()
                             else:
-                                try:
-                                    ilcsize.append(sys.maxint)
-                                except AttributeError:
-                                    ilcsize.append(sys.maxsize)
+                                ilcsize.append(float("inf"))
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
@@ -3714,7 +3731,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
-                        cfcontents, curcompression, compressionlevel, formatspecs)
+                        cfcontents, curcompression, compressionlevel, compressionuselist, formatspecs)
                     cfcontents.seek(0, 2)
                     cfsize = cfcontents.tell()
                     if(ucfsize > cfsize):
@@ -3756,7 +3773,7 @@ def AppendListsWithContent(inlist, fp, dirlistfromtxt=False, filevalues=[], extr
     inodetoforminode = {}
     numfiles = int(len(GetDirList))
     fnumfiles = format(numfiles, 'x').lower()
-    AppendFileHeader(fp, fnumfiles, "UTF-8", [], checksumtype[0], formatspecs)
+    AppendFileHeader(fp, numfiles, "UTF-8", [], checksumtype[0], formatspecs)
     for curfname in GetDirList:
         ftype = format(curfname[0], 'x').lower()
         fencoding = curfname[1]
@@ -3858,7 +3875,7 @@ def AppendFilesWithContentToOutFile(infiles, outfile, dirlistfromtxt=False, fmtt
                                    compresswholefile, compressionlevel, compressionuselist, followlink, checksumtype, formatspecs, verbose)
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -3882,7 +3899,7 @@ def AppendFilesWithContentToOutFile(infiles, outfile, dirlistfromtxt=False, fmtt
         return outvar
     elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
         upload_file_to_internet_file(fp, outfile)
     if(returnfp):
@@ -3938,7 +3955,7 @@ def AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt=False, fmtty
                                    compresswholefile, compressionlevel, followlink, checksumtype, formatspecs, verbose)
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -3962,7 +3979,7 @@ def AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt=False, fmtty
         return outvar
     elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
         upload_file_to_internet_file(fp, outfile)
     if(returnfp):
@@ -4653,13 +4670,13 @@ def UncompressBytesAltFP(fp, formatspecs=__file_format_multi_dict__):
     return filefp
 
 
-def CompressOpenFileAlt(fp, compression="auto", compressionlevel=None, formatspecs=__file_format_dict__):
+def CompressOpenFileAlt(fp, compression="auto", compressionlevel=None, compressionuselist=compressionlistalt, formatspecs=__file_format_dict__):
     if(not hasattr(fp, "read")):
         return False
     fp.seek(0, 0)
     if(not compression or compression == formatspecs['format_magic']):
         compression = "auto"
-    if(compression not in compressionlist and compression is None):
+    if(compression not in compressionuselist and compression is None):
         compression = "auto"
     if(compression == "gzip" and compression in compressionsupport):
         bytesfp = BytesIO()
@@ -4878,7 +4895,7 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
         outfile = RemoveWindowsPath(outfile)
     if(not compression or compression == formatspecs['format_magic']):
         compression = "auto"
-    if(compression not in compressionlist and compression is None):
+    if(compression not in compressionuselist and compression is None):
         compression = "auto"
     if(verbose):
         logging.basicConfig(format="%(message)s",
@@ -5045,7 +5062,7 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
         elif ftype in data_types:
             fsize = format(int(fstatinfo.st_size), 'x').lower()
         else:
-            fsize = format(int(fstatinfo.st_size)).lower()
+            fsize = format(int(fstatinfo.st_size), 'x').lower()
         fatime = format(int(fstatinfo.st_atime), 'x').lower()
         fmtime = format(int(fstatinfo.st_mtime), 'x').lower()
         fctime = format(int(fstatinfo.st_ctime), 'x').lower()
@@ -5092,11 +5109,14 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
         fcsize = format(int(0), 'x').lower()
         fcontents = BytesIO()
         fcencoding = "UTF-8"
-        if ftype in data_types:
+        curcompression = "none"
+        if not followlink and ftype in data_types:
             with open(fname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
                 fcencoding = GetFileEncoding(fcontents, False)
-                if(not compresswholefile):
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -5111,16 +5131,13 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                             fcontents.seek(0, 0)
                             cfcontents.seek(0, 0)
                             cfcontents = CompressOpenFileAlt(
-                                cfcontents, compressionuselist[ilmin], compressionlevel, formatspecs)
+                                cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, formatspecs)
                             if(cfcontents):
                                 cfcontents.seek(0, 2)
                                 ilcsize.append(cfcontents.tell())
                                 cfcontents.close()
                             else:
-                                try:
-                                    ilcsize.append(sys.maxint)
-                                except AttributeError:
-                                    ilcsize.append(sys.maxsize)
+                                ilcsize.append(float("inf"))
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
@@ -5129,7 +5146,7 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
-                        cfcontents, curcompression, compressionlevel, formatspecs)
+                        cfcontents, curcompression, compressionlevel, compressionuselist, formatspecs)
                     cfcontents.seek(0, 2)
                     cfsize = cfcontents.tell()
                     if(ucfsize > cfsize):
@@ -5137,15 +5154,16 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                         fcompression = curcompression
                         fcontents.close()
                         fcontents = cfcontents
-        if(fcompression == "none"):
-            fcompression = ""
-        if(followlink and (ftype == 1 or ftype == 2)):
+        elif followlink and (ftype == 1 or ftype == 2):
             if(not os.path.exists(flinkname)):
                 return False
             flstatinfo = os.stat(flinkname)
             with open(flinkname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
-                if(not compresswholefile):
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
+                fcencoding = GetFileEncoding(fcontents, False)
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -5160,16 +5178,13 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                             fcontents.seek(0, 0)
                             cfcontents.seek(0, 0)
                             cfcontents = CompressOpenFileAlt(
-                                cfcontents, compressionuselist[ilmin], compressionlevel, formatspecs)
+                                cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, formatspecs)
                             if(cfcontents):
                                 cfcontents.seek(0, 2)
                                 ilcsize.append(cfcontents.tell())
                                 cfcontents.close()
                             else:
-                                try:
-                                    ilcsize.append(sys.maxint)
-                                except AttributeError:
-                                    ilcsize.append(sys.maxsize)
+                                ilcsize.append(float("inf"))
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
@@ -5178,7 +5193,7 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
-                        cfcontents, curcompression, compressionlevel, formatspecs)
+                        cfcontents, curcompression, compressionlevel, compressionuselist, formatspecs)
                     cfcontents.seek(0, 2)
                     cfsize = cfcontents.tell()
                     if(ucfsize > cfsize):
@@ -5186,6 +5201,8 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                         fcompression = curcompression
                         fcontents.close()
                         fcontents = cfcontents
+        if(fcompression == "none"):
+            fcompression = ""
         fcontents.seek(0, 0)
         ftypehex = format(ftype, 'x').lower()
         tmpoutlist = [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
@@ -5201,7 +5218,7 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
             return False
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -5225,7 +5242,7 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
         return outvar
     elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
         upload_file_to_internet_file(fp, outfile)
     if(returnfp):
@@ -5263,7 +5280,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
         outfile = RemoveWindowsPath(outfile)
     if(not compression or compression == formatspecs['format_magic']):
         compression = "auto"
-    if(compression not in compressionlist and compression is None):
+    if(compression not in compressionuselist and compression is None):
         compression = "auto"
     if(verbose):
         logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
@@ -5338,7 +5355,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
                 if 'zstandard' in sys.modules:
                     infile = ZstdFile(fileobj=infile, mode="rb")
                 elif 'pyzstd' in sys.modules:
-                    fp = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
+                    infile = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
                 tarfp = tarfile.open(fileobj=infile, mode="r")
             else:
                 tarfp = tarfile.open(fileobj=infile, mode="r")
@@ -5350,7 +5367,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
                 if 'zstandard' in sys.modules:
                     infile = ZstdFile(fileobj=infile, mode="rb")
                 elif 'pyzstd' in sys.modules:
-                    fp = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
+                    infile = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
                 tarfp = tarfile.open(fileobj=infile, mode="r")
             else:
                 tarfp = tarfile.open(infile, "r")
@@ -5439,11 +5456,15 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
         fcsize = format(int(0), 'x').lower()
         fcontents = BytesIO()
         fcencoding = "UTF-8"
+        curcompression = "none"
         if ftype in data_types:
             fpc = tarfp.extractfile(member)
+            fpc.close()
             shutil.copyfileobj(fpc, fcontents)
+            typechecktest = CheckCompressionType(fcontents, closefp=False)
+            fcontents.seek(0, 0)
             fcencoding = GetFileEncoding(fcontents, False)
-            if(not compresswholefile):
+            if(typechecktest is False and not compresswholefile):
                 fcontents.seek(0, 2)
                 ucfsize = fcontents.tell()
                 fcontents.seek(0, 0)
@@ -5458,16 +5479,13 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
                         fcontents.seek(0, 0)
                         cfcontents.seek(0, 0)
                         cfcontents = CompressOpenFileAlt(
-                            cfcontents, compressionuselist[ilmin], compressionlevel, formatspecs)
+                            cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, formatspecs)
                         if(cfcontents):
                             cfcontents.seek(0, 2)
                             ilcsize.append(cfcontents.tell())
                             cfcontents.close()
                         else:
-                            try:
-                                ilcsize.append(sys.maxint)
-                            except AttributeError:
-                                ilcsize.append(sys.maxsize)
+                            ilcsize.append(float("inf"))
                         ilmin = ilmin + 1
                     ilcmin = ilcsize.index(min(ilcsize))
                     curcompression = compressionuselist[ilcmin]
@@ -5476,7 +5494,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
                 shutil.copyfileobj(fcontents, cfcontents)
                 cfcontents.seek(0, 0)
                 cfcontents = CompressOpenFileAlt(
-                    cfcontents, curcompression, compressionlevel, formatspecs)
+                    cfcontents, curcompression, compressionlevel, compressionuselist, formatspecs)
                 cfcontents.seek(0, 2)
                 cfsize = cfcontents.tell()
                 if(ucfsize > cfsize):
@@ -5501,7 +5519,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
             return False
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -5525,7 +5543,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
         return outvar
     elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
         upload_file_to_internet_file(fp, outfile)
     if(returnfp):
@@ -5559,7 +5577,7 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
         outfile = RemoveWindowsPath(outfile)
     if(not compression or compression == formatspecs['format_magic']):
         compression = "auto"
-    if(compression not in compressionlist and compression is None):
+    if(compression not in compressionuselist and compression is None):
         compression = "auto"
     if(verbose):
         logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
@@ -5737,10 +5755,13 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
             fgname = ""
         fcontents = BytesIO()
         fcencoding = "UTF-8"
-        if(ftype == 0):
+        curcompression = "none"
+        if ftype == 0:
             fcontents.write(zipfp.read(member.filename))
+            typechecktest = CheckCompressionType(fcontents, closefp=False)
+            fcontents.seek(0, 0)
             fcencoding = GetFileEncoding(fcontents, False)
-            if(not compresswholefile):
+            if(typechecktest is False and not compresswholefile):
                 fcontents.seek(0, 2)
                 ucfsize = fcontents.tell()
                 fcontents.seek(0, 0)
@@ -5755,7 +5776,7 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
                         fcontents.seek(0, 0)
                         cfcontents.seek(0, 0)
                         cfcontents = CompressOpenFileAlt(
-                            cfcontents, compressionuselist[ilmin], compressionlevel, formatspecs)
+                            cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, formatspecs)
                         cfcontents.seek(0, 2)
                         ilcsize.append(cfcontents.tell())
                         cfcontents.close()
@@ -5767,7 +5788,7 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
                 shutil.copyfileobj(fcontents, cfcontents)
                 cfcontents.seek(0, 0)
                 cfcontents = CompressOpenFileAlt(
-                    cfcontents, curcompression, compressionlevel, formatspecs)
+                    cfcontents, curcompression, compressionlevel, compressionuselist, formatspecs)
                 cfcontents.seek(0, 2)
                 cfsize = cfcontents.tell()
                 if(ucfsize > cfsize):
@@ -5792,7 +5813,7 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
             return False
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -5816,7 +5837,7 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
         return outvar
     elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
         upload_file_to_internet_file(fp, outfile)
     if(returnfp):
@@ -5855,7 +5876,7 @@ if(rarfile_support):
             outfile = RemoveWindowsPath(outfile)
         if(not compression or compression == formatspecs['format_magic']):
             compression = "auto"
-        if(compression not in compressionlist and compression is None):
+        if(compression not in compressionuselist and compression is None):
             compression = "auto"
         if(verbose):
             logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
@@ -6051,10 +6072,13 @@ if(rarfile_support):
                 fgname = ""
             fcontents = BytesIO()
             fcencoding = "UTF-8"
-            if(ftype == 0):
+            curcompression = "none"
+            if ftype == 0:
                 fcontents.write(rarfp.read(member.filename))
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
                 fcencoding = GetFileEncoding(fcontents, False)
-                if(not compresswholefile):
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -6069,16 +6093,13 @@ if(rarfile_support):
                             fcontents.seek(0, 0)
                             cfcontents.seek(0, 0)
                             cfcontents = CompressOpenFileAlt(
-                                cfcontents, compressionuselist[ilmin], compressionlevel, formatspecs)
+                                cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, formatspecs)
                             if(cfcontents):
                                 cfcontents.seek(0, 2)
                                 ilcsize.append(cfcontents.tell())
                                 cfcontents.close()
                             else:
-                                try:
-                                    ilcsize.append(sys.maxint)
-                                except AttributeError:
-                                    ilcsize.append(sys.maxsize)
+                                ilcsize.append(float("inf"))
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
@@ -6087,12 +6108,12 @@ if(rarfile_support):
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
-                        cfcontents, curcompression, compressionlevel, formatspecs)
+                        cfcontents, curcompression, compressionlevel, compressionuselist, formatspecs)
                     cfcontents.seek(0, 2)
                     cfsize = cfcontents.tell()
                     if(ucfsize > cfsize):
                         fcsize = format(int(cfsize), 'x').lower()
-                        fcompression = compression
+                        fcompression = curcompression
                         fcontents.close()
                         fcontents = cfcontents
             if(fcompression == "none"):
@@ -6112,7 +6133,7 @@ if(rarfile_support):
                 return False
         if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
             fp = CompressOpenFileAlt(
-                fp, compression, compressionlevel, formatspecs)
+                fp, compression, compressionlevel, compressionuselist, formatspecs)
             try:
                 fp.flush()
                 if(hasattr(os, "sync")):
@@ -6136,7 +6157,7 @@ if(rarfile_support):
             return outvar
         elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
             fp = CompressOpenFileAlt(
-                fp, compression, compressionlevel, formatspecs)
+                fp, compression, compressionlevel, compressionuselist, formatspecs)
             fp.seek(0, 0)
             upload_file_to_internet_file(fp, outfile)
         if(returnfp):
@@ -6175,7 +6196,7 @@ if(py7zr_support):
             outfile = RemoveWindowsPath(outfile)
         if(not compression or compression == formatspecs['format_magic']):
             compression = "auto"
-        if(compression not in compressionlist and compression is None):
+        if(compression not in compressionuselist and compression is None):
             compression = "auto"
         if(verbose):
             logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
@@ -6302,12 +6323,16 @@ if(py7zr_support):
                 fgname = ""
             fcontents = BytesIO()
             fcencoding = "UTF-8"
-            if(ftype == 0):
+            curcompression = "none"
+            if ftype == 0:
                 fcontents.write(file_content[member.filename].read())
-                fcencoding = GetFileEncoding(fcontents, False)
                 fsize = format(fcontents.tell(), 'x').lower()
+                fcontents.seek(0, 0)
+                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                fcontents.seek(0, 0)
+                fcencoding = GetFileEncoding(fcontents, False)
                 file_content[member.filename].close()
-                if(not compresswholefile):
+                if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
                     fcontents.seek(0, 0)
@@ -6322,16 +6347,13 @@ if(py7zr_support):
                             fcontents.seek(0, 0)
                             cfcontents.seek(0, 0)
                             cfcontents = CompressOpenFileAlt(
-                                cfcontents, compressionuselist[ilmin], compressionlevel, formatspecs)
+                                cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, formatspecs)
                             if(cfcontents):
                                 cfcontents.seek(0, 2)
                                 ilcsize.append(cfcontents.tell())
                                 cfcontents.close()
                             else:
-                                try:
-                                    ilcsize.append(sys.maxint)
-                                except AttributeError:
-                                    ilcsize.append(sys.maxsize)
+                                ilcsize.append(float("inf"))
                             ilmin = ilmin + 1
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
@@ -6340,7 +6362,7 @@ if(py7zr_support):
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
-                        cfcontents, curcompression, compressionlevel, formatspecs)
+                        cfcontents, curcompression, compressionlevel, compressionuselist, formatspecs)
                     cfcontents.seek(0, 2)
                     cfsize = cfcontents.tell()
                     if(ucfsize > cfsize):
@@ -6365,7 +6387,7 @@ if(py7zr_support):
                 return False
         if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
             fp = CompressOpenFileAlt(
-                fp, compression, compressionlevel, formatspecs)
+                fp, compression, compressionlevel, compressionuselist, formatspecs)
             try:
                 fp.flush()
                 if(hasattr(os, "sync")):
@@ -6389,7 +6411,7 @@ if(py7zr_support):
             return outvar
         elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
             fp = CompressOpenFileAlt(
-                fp, compression, compressionlevel, formatspecs)
+                fp, compression, compressionlevel, compressionuselist, formatspecs)
             fp.seek(0, 0)
             upload_file_to_internet_file(fp, outfile)
         if(returnfp):
@@ -7586,11 +7608,11 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
     if(fcompresstype==formatspecs['format_magic']):
         fcompresstype = ""
     outlist = {'fnumfiles': fnumfiles, 'fformat': formversions[0], 'fcompression': fcompresstype, 'fencoding': fhencoding, 'fversion': formversions[1], 'fostype': fostype, 'fheadersize': fheadsize, 'fsize': CatSizeEnd, 'fnumfields': fnumfields + 2, 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'frawheader': [formstring] + inheader, 'fextrafields': fnumextrafields, 'fextrafieldsize': fnumextrafieldsize, 'fextradata': fextrafieldslist, 'ffilelist': []}
-    if(seekstart < 0 and seekstart > fnumfiles):
+    if (seekstart < 0) or (seekstart > fnumfiles):
         seekstart = 0
-    if(seekend == 0 or seekend > fnumfiles and seekend < seekstart):
+    if (seekend == 0) or (seekend > fnumfiles) or (seekend < seekstart):
         seekend = fnumfiles
-    elif(seekend < 0 and abs(seekend) <= fnumfiles and abs(seekend) >= seekstart):
+    elif (seekend < 0) and (abs(seekend) <= fnumfiles) and (abs(seekend) >= seekstart):
         seekend = fnumfiles - abs(seekend)
     if(seekstart > 0):
         il = 0
@@ -7881,7 +7903,7 @@ def MultipleFoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listo
         infile = [infile]
     outretval = {}
     for curfname in infile:
-        curretfile = outretval.update({curfname: FoxFileToArray(curfname, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)})
+        curretfile[curfname] = ArchiveFileToArray(curfname, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
     return outretval
 
 def MultipleFoxFilesToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
@@ -8065,7 +8087,7 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
         outfile = RemoveWindowsPath(outfile)
     if(not compression or compression == formatspecs['format_magic']):
         compression = "auto"
-    if(compression not in compressionlist and compression is None):
+    if(compression not in compressionuselist and compression is None):
         compression = "auto"
     if(verbose):
         logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
@@ -8172,10 +8194,13 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
         fcontents = listfoxfiles['ffilelist'][reallcfi]['fcontents']
         if(not listfoxfiles['ffilelist'][reallcfi]['fcontentasfile']):
             fcontents = BytesIO(fcontents)
+        typechecktest = CheckCompressionType(fcontents, closefp=False)
+        fcontents.seek(0, 0)
         fcencoding = GetFileEncoding(fcontents, False)
         fcompression = ""
         fcsize = format(int(0), 'x').lower()
-        if(not compresswholefile):
+        curcompression = "none"
+        if typechecktest is False and not compresswholefile:
             fcontents.seek(0, 2)
             ucfsize = fcontents.tell()
             fcontents.seek(0, 0)
@@ -8190,16 +8215,13 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                     fcontents.seek(0, 0)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
-                        cfcontents, compressionuselist[ilmin], compressionlevel, formatspecs)
+                        cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, formatspecs)
                     if(cfcontents):
                         cfcontents.seek(0, 2)
                         ilcsize.append(cfcontents.tell())
                         cfcontents.close()
                     else:
-                        try:
-                            ilcsize.append(sys.maxint)
-                        except AttributeError:
-                            ilcsize.append(sys.maxsize)
+                        ilcsize.append(float("inf"))
                     ilmin = ilmin + 1
                 ilcmin = ilcsize.index(min(ilcsize))
                 curcompression = compressionuselist[ilcmin]
@@ -8208,7 +8230,7 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
             shutil.copyfileobj(fcontents, cfcontents)
             cfcontents.seek(0, 0)
             cfcontents = CompressOpenFileAlt(
-                cfcontents, curcompression, compressionlevel, formatspecs)
+                cfcontents, curcompression, compressionlevel, compressionuselist, formatspecs)
             cfcontents.seek(0, 2)
             cfsize = cfcontents.tell()
             if(ucfsize > cfsize):
@@ -8216,11 +8238,11 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                 fcompression = curcompression
                 fcontents.close()
                 fcontents = cfcontents
-        if(followlink):
-            if(listfoxfiles['ffilelist'][reallcfi]['ftype'] == 1 or listfoxfiles['ffilelist'][reallcfi]['ftype'] == 2):
-                getflinkpath = listfoxfiles['ffilelist'][reallcfi]['flinkname']
-                flinkid = prelistfoxfiles['filetoid'][getflinkpath]
-                flinkinfo = listfoxfiles['ffilelist'][flinkid]
+        if followlink:
+            if(listarchivefiles['ffilelist'][reallcfi]['ftype'] == 1 or listarchivefiles['ffilelist'][reallcfi]['ftype'] == 2):
+                getflinkpath = listarchivefiles['ffilelist'][reallcfi]['flinkname']
+                flinkid = prelistarchivefiles['filetoid'][getflinkpath]
+                flinkinfo = listarchivefiles['ffilelist'][flinkid]
                 fheadersize = format(
                     int(flinkinfo['fheadersize']), 'x').lower()
                 fsize = format(int(flinkinfo['fsize']), 'x').lower()
@@ -8257,7 +8279,7 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                 ftypehex = format(flinkinfo['ftype'], 'x').lower()
         else:
             ftypehex = format(
-                listfoxfiles['ffilelist'][reallcfi]['ftype'], 'x').lower()
+                listarchivefiles['ffilelist'][reallcfi]['ftype'], 'x').lower()
         fcurfid = format(curfid, 'x').lower()
         if(not followlink and finode != 0):
             if(listfoxfiles['ffilelist'][reallcfi]['ftype'] != 1):
@@ -8288,7 +8310,7 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
             return False
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -8312,7 +8334,7 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
         return outvar
     elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
         fp = CompressOpenFileAlt(
-            fp, compression, compressionlevel, formatspecs)
+            fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
         upload_file_to_internet_file(fp, outfile)
     if(returnfp):
@@ -8625,7 +8647,7 @@ def FoxFileListFiles(infile, fmttype="auto", seekstart=0, seekend=0, skipchecksu
     else:
         if(infile != "-" and not hasattr(infile, "read") and not hasattr(infile, "write") and not (sys.version_info[0] >= 3 and isinstance(infile, bytes))):
             infile = RemoveWindowsPath(infile)
-        listarchivefiles = ArchiveFileToArray(infile, fmttype, seekstart, seekend, True, False, False, skipchecksum, formatspecs, seektoend, returnfp)
+        listarchivefiles = FoxFileToArray(infile, fmttype, seekstart, seekend, True, False, False, skipchecksum, formatspecs, seektoend, returnfp)
     if(not listarchivefiles):
         return False
     lenlist = len(listarchivefiles['ffilelist'])
@@ -8721,7 +8743,7 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
                 if 'zstandard' in sys.modules:
                     infile = ZstdFile(fileobj=infile, mode="rb")
                 elif 'pyzstd' in sys.modules:
-                    fp = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
+                    infile = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
                 tarfp = tarfile.open(fileobj=infile, mode="r")
             else:
                 tarfp = tarfile.open(fileobj=infile, mode="r")
@@ -8733,7 +8755,7 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
                 if 'zstandard' in sys.modules:
                     infile = ZstdFile(fileobj=infile, mode="rb")
                 elif 'pyzstd' in sys.modules:
-                    fp = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
+                    infile = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
                 tarfp = tarfile.open(fileobj=infile, mode="r")
             else:
                 tarfp = tarfile.open(infile, "r")
@@ -9213,37 +9235,37 @@ def ListDirListFiles(infiles, dirlistfromtxt=False, compression="auto", compress
 PyNeoFile compatibility layer
 """
 
-def make_empty_file_pointer_neo(fp, fmttype=None, checksumtype='crc32', formatspecs=None, encoding='UTF-8'):
+def make_empty_file_pointer_neo(fp, fmttype=None, checksumtype='crc32', formatspecs=__file_format_multi_dict__, encoding='UTF-8'):
     return MakeEmptyFilePointer(fp, fmttype, checksumtype, formatspecs)
 
-def make_empty_archive_file_pointer_neo(fp, fmttype=None, checksumtype='crc32', formatspecs=None, encoding='UTF-8'):
+def make_empty_archive_file_pointer_neo(fp, fmttype=None, checksumtype='crc32', formatspecs=__file_format_multi_dict__, encoding='UTF-8'):
     return make_empty_file_pointer_neo(fp, fmttype, checksumtype, formatspecs, encoding)
 
-def make_empty_file_neo(outfile=None, fmttype=None, checksumtype='crc32', formatspecs=None, encoding='UTF-8', returnfp=False):
+def make_empty_file_neo(outfile=None, fmttype=None, checksumtype='crc32', formatspecs=__file_format_multi_dict__, encoding='UTF-8', returnfp=False):
     return MakeEmptyFile(outfile, fmttype, "auto", False, None, checksumtype, formatspecs, returnfp)
 
-def make_empty_archive_file_neo(outfile=None, fmttype=None, checksumtype='crc32', formatspecs=None, encoding='UTF-8', returnfp=False):
+def make_empty_archive_file_neo(outfile=None, fmttype=None, checksumtype='crc32', formatspecs=__file_format_multi_dict__, encoding='UTF-8', returnfp=False):
     return make_empty_file_neo(outfile, fmttype, checksumtype, formatspecs, encoding, returnfp)
 
-def pack_neo(infiles, outfile=None, formatspecs=None, checksumtypes=["crc32", "crc32", "crc32", "crc32"], encoding="UTF-8", compression="auto", compression_level=None, returnfp=False):
+def pack_neo(infiles, outfile=None, formatspecs=__file_format_multi_dict__, checksumtypes=["crc32", "crc32", "crc32", "crc32"], encoding="UTF-8", compression="auto", compression_level=None, returnfp=False):
     return PackFoxFile(infiles, outfile, False, "auto", compression, False, compression_level, compressionlistalt, False, checksumtypes, [], {}, formatspecs, False, returnfp)
 
-def archive_to_array_neo(infile, formatspecs=None, listonly=False, skipchecksum=False, uncompress=True, returnfp=False):
+def archive_to_array_neo(infile, formatspecs=__file_format_multi_dict__, listonly=False, skipchecksum=False, uncompress=True, returnfp=False):
     return FoxFileToArray(infile, "auto", 0, 0, listonly, True, uncompress, skipchecksum, formatspecs, False, returnfp)
 
-def unpack_neo(infile, outdir='.', formatspecs=None, skipchecksum=False, uncompress=True, returnfp=False):
+def unpack_neo(infile, outdir='.', formatspecs=__file_format_multi_dict__, skipchecksum=False, uncompress=True, returnfp=False):
     return UnPackFoxFile(infile, outdir, False, 0, 0, skipchecksum, formatspecs, True, True, False, False, returnfp)
 
-def repack_neo(infile, outfile=None, formatspecs=None, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
+def repack_neo(infile, outfile=None, formatspecs=__file_format_dict__, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
     return RePackFoxFile(infile, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
 
-def archivefilevalidate_neo(infile, formatspecs=None, verbose=False, return_details=False, returnfp=False):
+def archivefilevalidate_neo(infile, formatspecs=__file_format_multi_dict__, verbose=False, return_details=False, returnfp=False):
     return FoxFileValidate(infile, "auto", formatspecs, False, verbose, returnfp)
 
-def archivefilelistfiles_neo(infile, formatspecs=None, advanced=False, include_dirs=True, returnfp=False):
+def archivefilelistfiles_neo(infile, formatspecs=__file_format_multi_dict__, advanced=False, include_dirs=True, returnfp=False):
     return FoxFileListFiles(infile, "auto", 0, 0, False, formatspecs, False, True, advanced, returnfp)
 
-def convert_foreign_to_neo(infile, outfile=None, formatspecs=None, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
+def convert_foreign_to_neo(infile, outfile=None, formatspecs=__file_format_multi_dict__, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
     intmp = InFileToArray(infile, 0, 0, False, True, False, formatspecs, False, False)
     return RePackFoxFile(intmp, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
 
@@ -9767,9 +9789,9 @@ def upload_file_to_internet_file(ifp, url):
     return False
 
 
-def upload_file_to_internet_compress_file(ifp, url, compression="auto", compressionlevel=None, formatspecs=__file_format_dict__):
+def upload_file_to_internet_compress_file(ifp, url, compression="auto", compressionlevel=None, compressionuselist=compressionlistalt, formatspecs=__file_format_dict__):
     fp = CompressOpenFileAlt(
-        fp, compression, compressionlevel, formatspecs)
+        fp, compression, compressionlevel, compressionuselist, formatspecs)
     if(not foxfileout):
         return False
     fp.seek(0, 0)
@@ -9793,9 +9815,9 @@ def upload_file_to_internet_string(ifp, url):
     return False
 
 
-def upload_file_to_internet_compress_string(ifp, url, compression="auto", compressionlevel=None, formatspecs=__file_format_dict__):
+def upload_file_to_internet_compress_string(ifp, url, compression="auto", compressionlevel=None, compressionuselist=compressionlistalt, formatspecs=__file_format_dict__):
     fp = CompressOpenFileAlt(
-        BytesIO(ifp), compression, compressionlevel, formatspecs)
+        BytesIO(ifp), compression, compressionlevel, compressionuselist, formatspecs)
     if(not foxfileout):
         return False
     fp.seek(0, 0)