PyFoxFile 0.21.4__py3-none-any.whl → 0.22.4__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: 8/26/2025 Ver. 0.21.4 RC 1 - Author: cooldude2k $
+    $FileInfo: pyfoxfile.py - Last Update: 8/29/2025 Ver. 0.22.4 RC 1 - Author: cooldude2k $
 '''
 
 from __future__ import absolute_import, division, print_function, unicode_literals, generators, with_statement, nested_scopes
@@ -38,6 +38,7 @@ import zipfile
 import binascii
 import platform
 from io import StringIO, BytesIO
+import posixpath as pp  # POSIX-safe joins/normpaths
 try:
     from backports import tempfile
 except ImportError:
@@ -45,10 +46,10 @@ except ImportError:
 # FTP Support
 ftpssl = True
 try:
-    from ftplib import FTP, FTP_TLS
+    from ftplib import FTP, FTP_TLS, all_errors
 except ImportError:
     ftpssl = False
-    from ftplib import FTP
+    from ftplib import FTP, all_errors
 
 try:
     import ujson as json
@@ -102,9 +103,13 @@ baseint = tuple(baseint)
 
 # URL Parsing
 try:
-    from urllib.parse import urlparse, urlunparse
+    # Python 3
+    from urllib.parse import urlparse, urlunparse, unquote
+    from urllib.request import url2pathname
 except ImportError:
+    # Python 2
     from urlparse import urlparse, urlunparse
+    from urllib import unquote, url2pathname
 
 # Windows-specific setup
 if os.name == "nt":
@@ -266,6 +271,8 @@ def get_default_threads():
 
 
 __use_pysftp__ = False
+__upload_proto_support__ = "^(ftp|ftps|sftp|scp)://"
+__download_proto_support__ = "^(http|https|ftp|ftps|sftp|scp)://"
 if(not havepysftp):
     __use_pysftp__ = False
 __use_http_lib__ = "httpx"
@@ -383,13 +390,13 @@ __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, 21, 4, "RC 1", 1)
-__version_info__ = (0, 21, 4, "RC 1", 1)
-__version_date_info__ = (2025, 9, 26, "RC 1", 1)
+__version_info__ = (0, 22, 4, "RC 1", 1)
+__version_info__ = (0, 22, 4, "RC 1", 1)
+__version_date_info__ = (2025, 9, 29, "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: 9911cc0b37bf3b39652ce61ec29c1e2180f46e43 $"
+__revision_id__ = "$Id: c5f2e77a91df1432f3fb4213ee32b80c79427e3a $"
 if(__version_info__[4] is not None):
     __version_date_plusrc__ = __version_date__ + \
         "-" + str(__version_date_info__[4])
@@ -619,6 +626,182 @@ def _normalize_initial_data(data, isbytes, encoding):
             return str(data)
 
 
+def _split_posix(path_text):
+    """Split POSIX paths regardless of OS; return list of components."""
+    # Normalize leading './'
+    if path_text.startswith(u'./'):
+        path_text = path_text[2:]
+    # Strip redundant slashes
+    path_text = re.sub(u'/+', u'/', path_text)
+    # Drop trailing '/' so 'dir/' -> ['dir']
+    if path_text.endswith(u'/'):
+        path_text = path_text[:-1]
+    return path_text.split(u'/') if path_text else []
+
+def _is_abs_like(s):
+    """Absolute targets (POSIX or Windows-drive style)."""
+    return s.startswith(u'/') or s.startswith(u'\\') or re.match(u'^[A-Za-z]:[/\\\\]', s)
+
+def _resolves_outside(base_rel, target_rel):
+    """
+    Given a base directory (relative, POSIX) and a target (relative),
+    return True if base/target resolves outside of base.
+    We anchor under '/' so normpath is root-anchored and portable.
+    """
+    base_clean = u'/'.join(_split_posix(base_rel))
+    target_clean = u'/'.join(_split_posix(target_rel))
+    base_abs = u'/' + base_clean if base_clean else u'/'
+    combined = pp.normpath(pp.join(base_abs, target_clean))
+    if combined == base_abs or combined.startswith(base_abs + u'/'):
+        return False
+    return True
+
+
+def DetectTarBombFoxFileArray(listarrayfiles,
+                                 top_file_ratio_threshold=0.6,
+                                 min_members_for_ratio=4,
+                                 symlink_policy="escape-only",  # 'escape-only' | 'deny' | 'single-folder-only'
+                                 to_text=to_text):
+    """
+    Detect 'tarbomb-like' archives from FoxFileToArray/TarFileToArray dicts.
+
+    Parameters:
+      listarrayfiles: dict with key 'ffilelist' -> list of entries (requires 'fname')
+      top_file_ratio_threshold: float, fraction of root files considered tarbomb
+      min_members_for_ratio: int, minimum members before ratio heuristic applies
+      symlink_policy:
+        - 'escape-only': only symlinks that escape parent/are absolute are unsafe
+        - 'deny': any symlink is unsafe
+        - 'single-folder-only': symlinks allowed only if archive has a single top-level folder
+      to_text: normalization function (your provided to_text)
+
+    Returns dict with:
+      - is_tarbomb, reasons, total_members, top_level_entries, top_level_files_count,
+        has_absolute_paths, has_parent_traversal,
+        symlink_escapes_root (bool), symlink_issues (list[{entry,target,reason}])
+    """
+    files = listarrayfiles or {}
+    members = files.get('ffilelist') or []
+
+    names = []
+    has_abs = False
+    has_parent = False
+
+    # Symlink tracking
+    has_any_symlink = False
+    symlink_issues = []
+    any_symlink_escape = False
+
+    for m in members:
+        m = m or {}
+        name = to_text(m.get('fname', u""))
+
+        if _is_abs_like(name):
+            has_abs = True
+
+        parts = _split_posix(name)
+        if u'..' in parts:
+            has_parent = True
+
+        if not parts:
+            continue
+
+        norm_name = u'/'.join(parts)
+        names.append(norm_name)
+
+        # ---- Symlink detection ----
+        ftype = m.get('ftype')
+        is_symlink = (ftype == 2) or (to_text(ftype).lower() == u'symlink' if ftype is not None else False)
+        if is_symlink:
+            has_any_symlink = True
+            target = to_text(m.get('flinkname', u""))
+            # Absolute symlink target is unsafe
+            if _is_abs_like(target):
+                any_symlink_escape = True
+                symlink_issues.append({'entry': norm_name, 'target': target, 'reason': 'absolute symlink target'})
+            else:
+                parent = u'/'.join(parts[:-1])  # may be ''
+                if _resolves_outside(parent, target):
+                    any_symlink_escape = True
+                    symlink_issues.append({'entry': norm_name, 'target': target, 'reason': 'symlink escapes parent directory'})
+
+    total = len(names)
+    reasons = []
+    if total == 0:
+        return {
+            "is_tarbomb": False,
+            "reasons": ["archive contains no members"],
+            "total_members": 0,
+            "top_level_entries": [],
+            "top_level_files_count": 0,
+            "has_absolute_paths": has_abs,
+            "has_parent_traversal": has_parent,
+            "symlink_escapes_root": any_symlink_escape,
+            "symlink_issues": symlink_issues,
+        }
+
+    # Layout counts
+    top_counts = {}
+    top_level_files_count = 0
+    for name in names:
+        parts = name.split(u'/')
+        first = parts[0]
+        top_counts[first] = top_counts.get(first, 0) + 1
+        if len(parts) == 1:  # directly at archive root
+            top_level_files_count += 1
+
+    top_keys = sorted(top_counts.keys())
+    is_tarbomb = False
+
+    # Path-based dangers
+    if has_abs:
+        is_tarbomb = True
+        reasons.append("contains absolute paths (dangerous)")
+    if has_parent:
+        is_tarbomb = True
+        reasons.append("contains parent-traversal ('..') entries (dangerous)")
+    if any_symlink_escape:
+        is_tarbomb = True
+        reasons.append("contains symlinks that escape their parent directory")
+
+    # Symlink policy enforcement
+    if symlink_policy == "deny" and has_any_symlink:
+        is_tarbomb = True
+        reasons.append("symlinks present and policy is 'deny'")
+    elif symlink_policy == "single-folder-only" and has_any_symlink and len(top_keys) != 1:
+        is_tarbomb = True
+        reasons.append("symlinks present but archive lacks a single top-level folder")
+
+    # Tarbomb layout heuristics
+    if len(top_keys) == 1:
+        reasons.append("single top-level entry '{0}'".format(top_keys[0]))
+    else:
+        ratio = float(top_level_files_count) / float(total)
+        if total >= min_members_for_ratio and ratio > float(top_file_ratio_threshold):
+            is_tarbomb = True
+            reasons.append("high fraction of members ({0:.0%}) at archive root".format(ratio))
+        else:
+            max_bucket = max(top_counts.values()) if top_counts else 0
+            if max_bucket < total * 0.9:
+                is_tarbomb = True
+                reasons.append("multiple top-level entries with no dominant folder: {0}".format(
+                    u", ".join(top_keys[:10])))
+            else:
+                reasons.append("multiple top-level entries but one dominates")
+
+    return {
+        "is_tarbomb": bool(is_tarbomb),
+        "reasons": reasons,
+        "total_members": total,
+        "top_level_entries": top_keys,
+        "top_level_files_count": top_level_files_count,
+        "has_absolute_paths": has_abs,
+        "has_parent_traversal": has_parent,
+        "symlink_escapes_root": any_symlink_escape,
+        "symlink_issues": symlink_issues,
+    }
+
+
 def MkTempFile(data=None, inmem=__use_inmemfile__, isbytes=True, prefix=__project__,
                delete=True, encoding="utf-8"):
     """
@@ -685,6 +868,13 @@ def RemoveWindowsPath(dpath):
     """
     if not dpath:
         return ""
+    if re.match("^file://", dpath, re.IGNORECASE):
+        # Normalize to file:/// if it's a local path (no host)
+        if dpath.lower().startswith("file://") and not dpath.lower().startswith("file:///"):
+            # insert the extra slash
+            dpath = "file:///" + dpath[7:]
+        dparsed = urlparse(dpath)
+        dpath = url2pathname(dparsed.path)
     # Accept bytes and decode safely
     if isinstance(dpath, (bytes, bytearray)):
         dpath = dpath.decode("utf-8", "ignore")
@@ -700,6 +890,13 @@ def NormalizeRelativePath(inpath):
     """
     Ensures the path is relative unless it is absolute. Prepares consistent relative paths.
     """
+    if re.match("^file://", inpath, re.IGNORECASE):
+        # Normalize to file:/// if it's a local path (no host)
+        if inpath.lower().startswith("file://") and not inpath.lower().startswith("file:///"):
+            # insert the extra slash
+            inpath = "file:///" + inpath[7:]
+        dparsed = urlparse(inpath)
+        inpath = url2pathname(dparsed.path)
     inpath = RemoveWindowsPath(inpath)
     if os.path.isabs(inpath):
         outpath = inpath
@@ -756,6 +953,13 @@ def ListDir(dirpath, followlink=False, duplicates=False, include_regex=None, exc
     include_pattern = re.compile(include_regex) if include_regex else None
     exclude_pattern = re.compile(exclude_regex) if exclude_regex else None
     for mydirfile in dirpath:
+        if re.match("^file://", mydirfile, re.IGNORECASE):
+            # Normalize to file:/// if it's a local path (no host)
+            if mydirfile.lower().startswith("file://") and not mydirfile.lower().startswith("file:///"):
+                # insert the extra slash
+                mydirfile = "file:///" + mydirfile[7:]
+            dparsed = urlparse(mydirfile)
+            mydirfile = url2pathname(dparsed.path)
         if not os.path.exists(mydirfile):
             return False
         mydirfile = NormalizeRelativePath(mydirfile)
@@ -826,6 +1030,13 @@ def ListDirAdvanced(dirpath, followlink=False, duplicates=False, include_regex=N
     include_pattern = re.compile(include_regex) if include_regex else None
     exclude_pattern = re.compile(exclude_regex) if exclude_regex else None
     for mydirfile in dirpath:
+        if re.match("^file://", mydirfile, re.IGNORECASE):
+            # Normalize to file:/// if it's a local path (no host)
+            if mydirfile.lower().startswith("file://") and not mydirfile.lower().startswith("file:///"):
+                # insert the extra slash
+                mydirfile = "file:///" + mydirfile[7:]
+            dparsed = urlparse(mydirfile)
+            mydirfile = url2pathname(dparsed.path)
         if not os.path.exists(mydirfile):
             return False
         mydirfile = NormalizeRelativePath(mydirfile)
@@ -2035,7 +2246,7 @@ def ReadFileHeaderDataWoSize(fp, delimiter=__file_format_dict__['format_delimite
     if(headersize <= 0 or headernumfields <= 0):
         return []
     headerdata = ReadTillNullByteByNum(fp, delimiter, headernumfields)
-    #headerdata = ReadFileHeaderData(fp, headernumfields, delimiter);
+    #headerdata = ReadFileHeaderData(fp, headernumfields, delimiter)
     HeaderOut = preheaderdata + headerdata
     return HeaderOut
 
@@ -2522,22 +2733,20 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
     return outlist
 
 
-def ReadFileDataWithContent(fp, listonly=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__):
+def ReadFileDataWithContent(fp, filestart=0, listonly=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__):
     if(not hasattr(fp, "read")):
         return False
     delimiter = formatspecs['format_delimiter']
-    curloc = fp.tell()
+    curloc = filestart
     try:
-        fp.seek(0, 2);
+        fp.seek(0, 2)
     except OSError:
-        SeekToEndOfFile(fp);
+        SeekToEndOfFile(fp)
     except ValueError:
-        SeekToEndOfFile(fp);
-    CatSize = fp.tell();
-    CatSizeEnd = CatSize;
+        SeekToEndOfFile(fp)
+    CatSize = fp.tell()
+    CatSizeEnd = CatSize
     fp.seek(curloc, 0)
-    if(curloc > 0):
-        fp.seek(0, 0)
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
     formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
     formdelszie = len(formatspecs['format_delimiter'])
@@ -2552,8 +2761,6 @@ def ReadFileDataWithContent(fp, listonly=False, uncompress=True, skipchecksum=Fa
     else:
         inheader = ReadFileHeaderDataWoSize(
             fp, formatspecs['format_delimiter'])
-    if(curloc > 0):
-        fp.seek(curloc, 0)
     fprechecksumtype = inheader[-2]
     fprechecksum = inheader[-1]
     headercheck = ValidateHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, fprechecksum, formatspecs)
@@ -2577,22 +2784,20 @@ def ReadFileDataWithContent(fp, listonly=False, uncompress=True, skipchecksum=Fa
     return flist
 
 
-def ReadFileDataWithContentToArray(fp, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False):
+def ReadFileDataWithContentToArray(fp, filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False):
     if(not hasattr(fp, "read")):
         return False
     delimiter = formatspecs['format_delimiter']
-    curloc = fp.tell()
+    curloc = filestart
     try:
-        fp.seek(0, 2);
+        fp.seek(0, 2)
     except OSError:
-        SeekToEndOfFile(fp);
+        SeekToEndOfFile(fp)
     except ValueError:
-        SeekToEndOfFile(fp);
-    CatSize = fp.tell();
-    CatSizeEnd = CatSize;
+        SeekToEndOfFile(fp)
+    CatSize = fp.tell()
+    CatSizeEnd = CatSize
     fp.seek(curloc, 0)
-    if(curloc > 0):
-        fp.seek(0, 0)
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
     formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
     formdelszie = len(formatspecs['format_delimiter'])
@@ -2624,8 +2829,6 @@ def ReadFileDataWithContentToArray(fp, seekstart=0, seekend=0, listonly=False, c
                 fextrafieldslist = json.loads(fextrafieldslist[0])
             except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                 pass
-    if(curloc > 0):
-        fp.seek(curloc, 0)
     formversion = re.findall("([\\d]+)", formstring)
     fheadsize = int(inheader[0], 16)
     fnumfields = int(inheader[1], 16)
@@ -2644,7 +2847,7 @@ def ReadFileDataWithContentToArray(fp, seekstart=0, seekend=0, listonly=False, c
         return False
     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': []}
+    outlist = {'fnumfiles': fnumfiles, 'ffilestart': filestart, '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) or (seekstart > fnumfiles):
         seekstart = 0
     if (seekend == 0) or (seekend > fnumfiles) or (seekend < seekstart):
@@ -2737,22 +2940,20 @@ def ReadFileDataWithContentToArray(fp, seekstart=0, seekend=0, listonly=False, c
     return outlist
 
 
-def ReadFileDataWithContentToList(fp, seekstart=0, seekend=0, listonly=False, contentasfile=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False):
+def ReadFileDataWithContentToList(fp, filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False):
     if(not hasattr(fp, "read")):
         return False
     delimiter = formatspecs['format_delimiter']
-    curloc = fp.tell()
+    curloc = filestart
     try:
-        fp.seek(0, 2);
+        fp.seek(0, 2)
     except OSError:
-        SeekToEndOfFile(fp);
+        SeekToEndOfFile(fp)
     except ValueError:
-        SeekToEndOfFile(fp);
-    CatSize = fp.tell();
-    CatSizeEnd = CatSize;
+        SeekToEndOfFile(fp)
+    CatSize = fp.tell()
+    CatSizeEnd = CatSize
     fp.seek(curloc, 0)
-    if(curloc > 0):
-        fp.seek(0, 0)
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
     formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
     formdelszie = len(formatspecs['format_delimiter'])
@@ -2784,8 +2985,6 @@ def ReadFileDataWithContentToList(fp, seekstart=0, seekend=0, listonly=False, co
                 fextrafieldslist = json.loads(fextrafieldslist[0])
             except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                 pass
-    if(curloc > 0):
-        fp.seek(curloc, 0)
     formversion = re.findall("([\\d]+)", formstring)
     fheadsize = int(inheader[0], 16)
     fnumfields = int(inheader[1], 16)
@@ -2903,25 +3102,25 @@ def ReadFileDataWithContentToList(fp, seekstart=0, seekend=0, listonly=False, co
     return outlist
 
 
-def ReadInFileWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
+def ReadInFileWithContentToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
     if(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype in formatspecs):
         formatspecs = formatspecs[fmttype]
     elif(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype not in formatspecs):
         fmttype = "auto"
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         fp = infile
-        fp.seek(0, 0)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         else:
-            fp.seek(0, 0)
-            checkcompressfile = CheckCompressionSubType(fp, formatspecs, False)
+            fp.seek(filestart, 0)
+            checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, False)
             if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
                 formatspecs = formatspecs[checkcompressfile]
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, True)
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
             return TarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
@@ -2956,58 +3155,58 @@ def ReadInFileWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0,
                 compresscheck = "zlib"
             else:
                 return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     elif(infile == "-"):
         fp = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, fp)
         else:
             shutil.copyfileobj(sys.stdin, fp)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        fp.seek(0, 0)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        fp.seek(filestart, 0)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         else:
-            fp.seek(0, 0)
-            checkcompressfile = CheckCompressionSubType(fp, formatspecs, False)
+            fp.seek(filestart, 0)
+            checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, False)
             if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
                 formatspecs = formatspecs[checkcompressfile]
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
         if(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
         fp = MkTempFile()
         fp.write(infile)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        fp.seek(0, 0)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        fp.seek(filestart, 0)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         else:
-            fp.seek(0, 0)
-            checkcompressfile = CheckCompressionSubType(fp, formatspecs, False)
+            fp.seek(filestart, 0)
+            checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, False)
             if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
                 formatspecs = formatspecs[checkcompressfile]
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
         if(not fp):
             return False
-        fp.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
+        fp.seek(filestart, 0)
+    elif(re.findall(__download_proto_support__, infile)):
         fp = download_file_from_internet_file(infile)
-        fp.seek(0, 0)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         else:
-            fp.seek(0, 0)
-            checkcompressfile = CheckCompressionSubType(fp, formatspecs, False)
+            fp.seek(filestart, 0)
+            checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, False)
             if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
                 formatspecs = formatspecs[checkcompressfile]
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
         if(not compresscheck):
             fextname = os.path.splitext(infile)[1]
             if(fextname == ".gz"):
@@ -3028,14 +3227,14 @@ def ReadInFileWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0,
                 compresscheck = "zlib"
             else:
                 return False
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
         if(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     else:
         infile = RemoveWindowsPath(infile)
-        checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+        checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
@@ -3050,7 +3249,7 @@ def ReadInFileWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0,
             return False
         elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
             return False
-        compresscheck = CheckCompressionType(infile, formatspecs, True)
+        compresscheck = CheckCompressionType(infile, formatspecs, filestart, True)
         if(not compresscheck):
             fextname = os.path.splitext(infile)[1]
             if(fextname == ".gz"):
@@ -3073,43 +3272,43 @@ def ReadInFileWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0,
                 return False
         if(not compresscheck):
             return False
-        fp = UncompressFile(infile, formatspecs, "rb")
-    return ReadFileDataWithContentToArray(fp, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+        fp = UncompressFile(infile, formatspecs, "rb", filestart)
+    return ReadFileDataWithContentToArray(fp, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
 
 
-def ReadInMultipleFileWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
+def ReadInMultipleFileWithContentToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
     if(isinstance(infile, (list, tuple, ))):
         pass
     else:
         infile = [infile]
     outretval = {}
     for curfname in infile:
-        outretval[curfname] = ReadInFileWithContentToArray(curfname, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+        outretval[curfname] = ReadInFileWithContentToArray(curfname, fmttype, filestart, 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):
-    return ReadInMultipleFileWithContentToArray(infile, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+def ReadInMultipleFilesWithContentToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
+    return ReadInMultipleFileWithContentToArray(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
 
 
-def ReadInFileWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
+def ReadInFileWithContentToList(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
     if(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype in formatspecs):
         formatspecs = formatspecs[fmttype]
     elif(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype not in formatspecs):
         fmttype = "auto"
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         fp = infile
-        fp.seek(0, 0)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         else:
-            fp.seek(0, 0)
-            checkcompressfile = CheckCompressionSubType(fp, formatspecs, False)
+            fp.seek(filestart, 0)
+            checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, False)
             if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
                 formatspecs = formatspecs[checkcompressfile]
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, True)
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
             return TarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
@@ -3144,58 +3343,58 @@ def ReadInFileWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0,
                 compresscheck = "zlib"
             else:
                 return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     elif(infile == "-"):
         fp = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, fp)
         else:
             shutil.copyfileobj(sys.stdin, fp)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        fp.seek(0, 0)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        fp.seek(filestart, 0)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         else:
-            fp.seek(0, 0)
-            checkcompressfile = CheckCompressionSubType(fp, formatspecs, False)
+            fp.seek(filestart, 0)
+            checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, False)
             if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
                 formatspecs = formatspecs[checkcompressfile]
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
         if(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
         fp = MkTempFile()
         fp.write(infile)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        fp.seek(0, 0)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        fp.seek(filestart, 0)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         else:
-            fp.seek(0, 0)
-            checkcompressfile = CheckCompressionSubType(fp, formatspecs, False)
+            fp.seek(filestart, 0)
+            checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, False)
             if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
                 formatspecs = formatspecs[checkcompressfile]
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
         if(not fp):
             return False
-        fp.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
+        fp.seek(filestart, 0)
+    elif(re.findall(__download_proto_support__, infile)):
         fp = download_file_from_internet_file(infile)
-        fp.seek(0, 0)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         else:
-            fp.seek(0, 0)
-            checkcompressfile = CheckCompressionSubType(fp, formatspecs, False)
+            fp.seek(filestart, 0)
+            checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, False)
             if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
                 formatspecs = formatspecs[checkcompressfile]
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
         if(not compresscheck):
             fextname = os.path.splitext(infile)[1]
             if(fextname == ".gz"):
@@ -3216,14 +3415,14 @@ def ReadInFileWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0,
                 compresscheck = "zlib"
             else:
                 return False
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
         if(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     else:
         infile = RemoveWindowsPath(infile)
-        checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+        checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
@@ -3238,7 +3437,7 @@ def ReadInFileWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0,
             return False
         elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
             return False
-        compresscheck = CheckCompressionType(infile, formatspecs, True)
+        compresscheck = CheckCompressionType(infile, formatspecs, filestart, True)
         if(not compresscheck):
             fextname = os.path.splitext(infile)[1]
             if(fextname == ".gz"):
@@ -3261,22 +3460,22 @@ def ReadInFileWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0,
                 return False
         if(not compresscheck):
             return False
-        fp = UncompressFile(infile, formatspecs, "rb")
-    return ReadFileDataWithContentToList(fp, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+        fp = UncompressFile(infile, formatspecs, "rb", filestart)
+    return ReadFileDataWithContentToList(fp, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
 
 
-def ReadInMultipleFileWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
+def ReadInMultipleFileWithContentToList(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
     if(isinstance(infile, (list, tuple, ))):
         pass
     else:
         infile = [infile]
     outretval = {}
     for curfname in infile:
-        curretfile[curfname] = ReadInFileWithContentToList(curfname, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+        curretfile[curfname] = ReadInFileWithContentToList(curfname, fmttype, filestart, 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):
-    return ReadInMultipleFileWithContentToList(infile, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+def ReadInMultipleFilesWithContentToList(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
+    return ReadInMultipleFileWithContentToList(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
 
 
 def AppendNullByte(indata, delimiter=__file_format_dict__['format_delimiter']):
@@ -3405,7 +3604,7 @@ def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile
         fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
-    elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif(re.findall(__upload_proto_support__, outfile)):
         fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
@@ -3441,7 +3640,7 @@ def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile
         outvar = fp.read()
         fp.close()
         return outvar
-    elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif(re.findall(__upload_proto_support__, outfile)):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
@@ -3745,9 +3944,9 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
         if not followlink and ftype in data_types:
             with open(fname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
-                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
-                fcencoding = GetFileEncoding(fcontents, False)
+                fcencoding = GetFileEncoding(fcontents, 0, False)
                 if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
@@ -3792,9 +3991,9 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
             flstatinfo = os.stat(flinkname)
             with open(flinkname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
-                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
-                fcencoding = GetFileEncoding(fcontents, False)
+                fcencoding = GetFileEncoding(fcontents, 0, False)
                 if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
@@ -3904,7 +4103,7 @@ def AppendListsWithContent(inlist, fp, dirlistfromtxt=False, filevalues=[], extr
         fheaderchecksumtype = curfname[26]
         fcontentchecksumtype = curfname[27]
         fcontents = curfname[28]
-        fencoding = GetFileEncoding(fcontents, False)
+        fencoding = GetFileEncoding(fcontents, 0, False)
         tmpoutlist = [ftype, fencoding, fcencoding, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression, fcsize,
                       fuid, funame, fgid, fgname, fid, finode, flinkcount, fdev, fdev_minor, fdev_major, fseeknextfile]
         fcontents.seek(0, 0)
@@ -3954,7 +4153,7 @@ def AppendFilesWithContentToOutFile(infiles, outfile, dirlistfromtxt=False, fmtt
         fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
-    elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif(re.findall(__upload_proto_support__, outfile)):
         fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
@@ -3991,7 +4190,7 @@ def AppendFilesWithContentToOutFile(infiles, outfile, dirlistfromtxt=False, fmtt
         outvar = fp.read()
         fp.close()
         return outvar
-    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall(__upload_proto_support__, outfile)):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
@@ -4034,7 +4233,7 @@ def AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt=False, fmtty
         fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
-    elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif(re.findall(__upload_proto_support__, outfile)):
         fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
@@ -4071,7 +4270,7 @@ def AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt=False, fmtty
         outvar = fp.read()
         fp.close()
         return outvar
-    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall(__upload_proto_support__, outfile)):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
@@ -4155,7 +4354,8 @@ def GzipCompressData(data, compresslevel=9):
         out = MkTempFile()
         with gzip.GzipFile(fileobj=out, mode="wb", compresslevel=compresslevel) as f:
             f.write(data)
-        compressed_data = out.getvalue()
+        out.seek(0, 0)
+        compressed_data = out.read()
     return compressed_data
 
 
@@ -4253,7 +4453,7 @@ def IsSingleDict(variable):
     return True
 
 
-def GetFileEncoding(infile, closefp=True):
+def GetFileEncoding(infile, filestart=0, closefp=True):
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         fp = infile
     else:
@@ -4262,19 +4462,19 @@ def GetFileEncoding(infile, closefp=True):
         except FileNotFoundError:
             return False
     file_encoding = "UTF-8"
-    fp.seek(0, 0)
+    fp.seek(filestart, 0)
     prefp = fp.read(2)
     if(prefp == binascii.unhexlify("fffe")):
         file_encoding = "UTF-16LE"
     elif(prefp == binascii.unhexlify("feff")):
         file_encoding = "UTF-16BE"
-    fp.seek(0, 0)
+    fp.seek(filestart, 0)
     prefp = fp.read(3)
     if(prefp == binascii.unhexlify("efbbbf")):
         file_encoding = "UTF-8"
     elif(prefp == binascii.unhexlify("0efeff")):
         file_encoding = "SCSU"
-    fp.seek(0, 0)
+    fp.seek(filestart, 0)
     prefp = fp.read(4)
     if(prefp == binascii.unhexlify("fffe0000")):
         file_encoding = "UTF-32LE"
@@ -4290,21 +4490,21 @@ def GetFileEncoding(infile, closefp=True):
         file_encoding = "UTF-7"
     elif(prefp == binascii.unhexlify("2b2f762f")):
         file_encoding = "UTF-7"
-    fp.seek(0, 0)
+    fp.seek(filestart, 0)
     if(closefp):
         fp.close()
     return file_encoding
 
 
-def GetFileEncodingFromString(instring, closefp=True):
+def GetFileEncodingFromString(instring, filestart=0, closefp=True):
     try:
         instringsfile = MkTempFile(instring)
     except TypeError:
         instringsfile = MkTempFile(instring.encode("UTF-8"))
-    return GetFileEncoding(instringsfile, closefp)
+    return GetFileEncoding(instringsfile, filestart, closefp)
 
 
-def CheckCompressionType(infile, formatspecs=__file_format_multi_dict__, closefp=True):
+def CheckCompressionType(infile, formatspecs=__file_format_multi_dict__, filestart=0, closefp=True):
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         fp = infile
     else:
@@ -4313,7 +4513,8 @@ def CheckCompressionType(infile, formatspecs=__file_format_multi_dict__, closefp
         except FileNotFoundError:
             return False
     filetype = False
-    fp.seek(0, 0)
+    curloc = filestart
+    fp.seek(filestart, 0)
     prefp = fp.read(2)
     if(prefp == binascii.unhexlify("1f8b")):
         filetype = "gzip"
@@ -4329,13 +4530,13 @@ def CheckCompressionType(infile, formatspecs=__file_format_multi_dict__, closefp
         filetype = "zlib"
     elif(prefp == binascii.unhexlify("1f9d")):
         filetype = "zcompress"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(3)
     if(prefp == binascii.unhexlify("425a68")):
         filetype = "bzip2"
     elif(prefp == binascii.unhexlify("5d0000")):
         filetype = "lzma"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(4)
     if(prefp == binascii.unhexlify("28b52ffd")):
         filetype = "zstd"
@@ -4347,29 +4548,29 @@ def CheckCompressionType(infile, formatspecs=__file_format_multi_dict__, closefp
         filetype = "zipfile"
     elif(prefp == binascii.unhexlify("504b0708")):
         filetype = "zipfile"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(5)
     if(prefp == binascii.unhexlify("7573746172")):
         filetype = "tarfile"
     if(prefp == binascii.unhexlify("7573746172")):
         filetype = "tarfile"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(6)
     if(prefp == binascii.unhexlify("fd377a585a00")):
         filetype = "xz"
     elif(prefp == binascii.unhexlify("377abcaf271c")):
         filetype = "7zipfile"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(7)
     if(prefp == binascii.unhexlify("526172211a0700")):
         filetype = "rarfile"
     elif(prefp == binascii.unhexlify("2a2a4143452a2a")):
         filetype = "ace"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(7)
     if(prefp == binascii.unhexlify("894c5a4f0d0a1a")):
         filetype = "lzo"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(8)
     if(prefp == binascii.unhexlify("7573746172003030")):
         filetype = "tarfile"
@@ -4377,7 +4578,7 @@ def CheckCompressionType(infile, formatspecs=__file_format_multi_dict__, closefp
         filetype = "tarfile"
     if(prefp == binascii.unhexlify("526172211a070100")):
         filetype = "rarfile"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     if(IsNestedDict(formatspecs)):
         for key, value in formatspecs.items():
             prefp = fp.read(formatspecs[key]['format_len'])
@@ -4393,7 +4594,7 @@ def CheckCompressionType(infile, formatspecs=__file_format_multi_dict__, closefp
                 if(formstring == inheaderver and formdel == formatspecs[key]['format_delimiter']):
                     filetype = formatspecs[key]['format_magic']
                     continue
-            fp.seek(0, 0)
+            fp.seek(curloc, 0)
     elif(IsSingleDict(formatspecs)):
         prefp = fp.read(formatspecs['format_len'])
         if(prefp == binascii.unhexlify(formatspecs['format_hex'])):
@@ -4408,15 +4609,15 @@ def CheckCompressionType(infile, formatspecs=__file_format_multi_dict__, closefp
             filetype = formatspecs['format_magic']
     else:
         pass
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(9)
     if(prefp == binascii.unhexlify("894c5a4f000d0a1a0a")):
         filetype = "lzo"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(10)
     if(prefp == binascii.unhexlify("7061785f676c6f62616c")):
         filetype = "tarfile"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     if(filetype == "gzip" or filetype == "bzip2" or filetype == "lzma" or filetype == "zstd" or filetype == "lz4" or filetype == "zlib"):
         if(TarFileCheck(fp)):
             filetype = "tarfile"
@@ -4431,14 +4632,15 @@ def CheckCompressionType(infile, formatspecs=__file_format_multi_dict__, closefp
             return "7zipfile"
         else:
             filetype = False
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     if(closefp):
         fp.close()
     return filetype
 
 
-def CheckCompressionSubType(infile, formatspecs=__file_format_multi_dict__, closefp=True):
-    compresscheck = CheckCompressionType(infile, formatspecs, False)
+def CheckCompressionSubType(infile, formatspecs=__file_format_multi_dict__, filestart=0, closefp=True):
+    compresscheck = CheckCompressionType(infile, formatspecs, filestart, False)
+    curloc = filestart
     if(not compresscheck):
         fextname = os.path.splitext(infile)[1]
         if(fextname == ".gz"):
@@ -4487,7 +4689,7 @@ def CheckCompressionSubType(infile, formatspecs=__file_format_multi_dict__, clos
     elif(py7zr_support and compresscheck == "7zipfile" and py7zr.is_7zfile(infile)):
         return "7zipfile"
     if(hasattr(infile, "read") or hasattr(infile, "write")):
-        fp = UncompressFileAlt(infile, formatspecs)
+        fp = UncompressFileAlt(infile, formatspecs, filestart)
     else:
         try:
             if(compresscheck == "gzip" and compresscheck in compressionsupport):
@@ -4517,10 +4719,11 @@ def CheckCompressionSubType(infile, formatspecs=__file_format_multi_dict__, clos
         except FileNotFoundError:
             return False
     filetype = False
+    fp.seek(filestart, 0)
     prefp = fp.read(5)
     if(prefp == binascii.unhexlify("7573746172")):
         filetype = "tarfile"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     if(IsNestedDict(formatspecs)):
         for key, value in formatspecs.items():
             prefp = fp.read(formatspecs[key]['format_len'])
@@ -4536,7 +4739,7 @@ def CheckCompressionSubType(infile, formatspecs=__file_format_multi_dict__, clos
                 if(formstring == inheaderver and formdel == formatspecs[key]['format_delimiter']):
                     filetype = formatspecs[key]['format_magic']
                     continue
-            fp.seek(0, 0)
+            fp.seek(curloc, 0)
     elif(IsSingleDict(formatspecs)):
         prefp = fp.read(formatspecs['format_len'])
         if(prefp == binascii.unhexlify(formatspecs['format_hex'])):
@@ -4551,36 +4754,36 @@ def CheckCompressionSubType(infile, formatspecs=__file_format_multi_dict__, clos
             filetype = formatspecs['format_magic']
     else:
         pass
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(10)
     if(prefp == binascii.unhexlify("7061785f676c6f62616c")):
         filetype = "tarfile"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     if(closefp):
         fp.close()
     return filetype
 
 
-def CheckCompressionTypeFromString(instring, formatspecs=__file_format_multi_dict__, closefp=True):
+def CheckCompressionTypeFromString(instring, formatspecs=__file_format_multi_dict__, filestart=0, closefp=True):
     try:
         instringsfile = MkTempFile(instring)
     except TypeError:
         instringsfile = MkTempFile(instring.encode("UTF-8"))
-    return CheckCompressionType(instringsfile, formatspecs, closefp)
+    return CheckCompressionType(instringsfile, formatspecs, filestart, closefp)
 
 
-def CheckCompressionTypeFromBytes(instring, formatspecs=__file_format_multi_dict__, closefp=True):
+def CheckCompressionTypeFromBytes(instring, formatspecs=__file_format_multi_dict__, filestart=0, closefp=True):
     try:
         instringsfile = MkTempFile(instring)
     except TypeError:
         instringsfile = MkTempFile(instring.decode("UTF-8"))
-    return CheckCompressionType(instringsfile, formatspecs, closefp)
+    return CheckCompressionType(instringsfile, formatspecs, filestart, closefp)
 
 
-def UncompressFileAlt(fp, formatspecs=__file_format_multi_dict__):
+def UncompressFileAlt(fp, formatspecs=__file_format_multi_dict__, filestart=0):
     if(not hasattr(fp, "read")):
         return False
-    compresscheck = CheckCompressionType(fp, formatspecs, False)
+    compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
     if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
         formatspecs = formatspecs[compresscheck]
     if(compresscheck == "gzip" and compresscheck in compressionsupport):
@@ -4614,8 +4817,8 @@ def UncompressFileAlt(fp, formatspecs=__file_format_multi_dict__):
     return fp
 
 
-def UncompressFile(infile, formatspecs=__file_format_multi_dict__, mode="rb"):
-    compresscheck = CheckCompressionType(infile, formatspecs, False)
+def UncompressFile(infile, formatspecs=__file_format_multi_dict__, mode="rb", filestart=0):
+    compresscheck = CheckCompressionType(infile, formatspecs, filestart, False)
     if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
         formatspecs = formatspecs[compresscheck]
     if(sys.version_info[0] == 2 and compresscheck):
@@ -4661,8 +4864,8 @@ def UncompressFile(infile, formatspecs=__file_format_multi_dict__, mode="rb"):
     return filefp
 
 
-def UncompressString(infile, formatspecs=__file_format_multi_dict__):
-    compresscheck = CheckCompressionTypeFromString(infile, formatspecs, False)
+def UncompressString(infile, formatspecs=__file_format_multi_dict__, filestart=0):
+    compresscheck = CheckCompressionTypeFromString(infile, formatspecs, filestart, False)
     if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
         formatspecs = formatspecs[compresscheck]
     if(compresscheck == "gzip" and compresscheck in compressionsupport):
@@ -4689,32 +4892,32 @@ def UncompressString(infile, formatspecs=__file_format_multi_dict__):
     return fileuz
 
 
-def UncompressStringAlt(instring, formatspecs=__file_format_multi_dict__):
+def UncompressStringAlt(instring, formatspecs=__file_format_multi_dict__, filestart=0):
     filefp = StringIO()
-    outstring = UncompressString(instring, formatspecs)
+    outstring = UncompressString(instring, formatspecs, filestart)
     filefp.write(outstring)
     filefp.seek(0, 0)
     return filefp
 
-def UncompressStringAltFP(fp, formatspecs=__file_format_multi_dict__):
+def UncompressStringAltFP(fp, formatspecs=__file_format_multi_dict__, filestart=0):
     if(not hasattr(fp, "read")):
         return False
-    prechck = CheckCompressionType(fp, formatspecs, False)
+    prechck = CheckCompressionType(fp, formatspecs, filestart, False)
     if(IsNestedDict(formatspecs) and prechck in formatspecs):
         formatspecs = formatspecs[prechck]
-    fp.seek(0, 0)
+    fp.seek(filestart, 0)
     if(prechck!="zstd"):
-        return UncompressFileAlt(fp, formatspecs)
+        return UncompressFileAlt(fp, formatspecs, filestart)
     filefp = StringIO()
-    fp.seek(0, 0)
-    outstring = UncompressString(fp.read(), formatspecs)
+    fp.seek(filestart, 0)
+    outstring = UncompressString(fp.read(), formatspecs, 0)
     filefp.write(outstring)
     filefp.seek(0, 0)
     return filefp
 
 
-def UncompressBytes(infile, formatspecs=__file_format_multi_dict__):
-    compresscheck = CheckCompressionTypeFromBytes(infile, formatspecs, False)
+def UncompressBytes(infile, formatspecs=__file_format_multi_dict__, filestart=0):
+    compresscheck = CheckCompressionTypeFromBytes(infile, formatspecs, filestart, False)
     if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
         formatspecs = formatspecs[compresscheck]
     if(compresscheck == "gzip" and compresscheck in compressionsupport):
@@ -4739,26 +4942,26 @@ def UncompressBytes(infile, formatspecs=__file_format_multi_dict__):
     return fileuz
 
 
-def UncompressBytesAlt(inbytes, formatspecs=__file_format_multi_dict__):
+def UncompressBytesAlt(inbytes, formatspecs=__file_format_multi_dict__, filestart=0):
     filefp = MkTempFile()
-    outstring = UncompressBytes(inbytes, formatspecs)
+    outstring = UncompressBytes(inbytes, formatspecs, filestart)
     filefp.write(outstring)
     filefp.seek(0, 0)
     return filefp
 
 
-def UncompressBytesAltFP(fp, formatspecs=__file_format_multi_dict__):
+def UncompressBytesAltFP(fp, formatspecs=__file_format_multi_dict__, filestart=0):
     if(not hasattr(fp, "read")):
         return False
-    prechck = CheckCompressionType(fp, formatspecs, False)
+    prechck = CheckCompressionType(fp, formatspecs, filestart, False)
     if(IsNestedDict(formatspecs) and prechck in formatspecs):
         formatspecs = formatspecs[prechck]
-    fp.seek(0, 0)
+    fp.seek(filestart, 0)
     if(prechck!="zstd"):
-        return UncompressFileAlt(fp, formatspecs)
+        return UncompressFileAlt(fp, formatspecs, filestart)
     filefp = MkTempFile()
-    fp.seek(0, 0)
-    outstring = UncompressBytes(fp.read(), formatspecs)
+    fp.seek(filestart, 0)
+    outstring = UncompressBytes(fp.read(), formatspecs, 0)
     filefp.write(outstring)
     filefp.seek(0, 0)
     return filefp
@@ -5005,7 +5208,7 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
         fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
-    elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif(re.findall(__upload_proto_support__, outfile)):
         fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
@@ -5207,9 +5410,9 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
         if not followlink and ftype in data_types:
             with open(fname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
-                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
-                fcencoding = GetFileEncoding(fcontents, False)
+                fcencoding = GetFileEncoding(fcontents, 0, False)
                 if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
@@ -5254,9 +5457,9 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
             flstatinfo = os.stat(flinkname)
             with open(flinkname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
-                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
-                fcencoding = GetFileEncoding(fcontents, False)
+                fcencoding = GetFileEncoding(fcontents, 0, False)
                 if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
@@ -5334,7 +5537,7 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
         outvar = fp.read()
         fp.close()
         return outvar
-    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall(__upload_proto_support__, outfile)):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
@@ -5389,7 +5592,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
         fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
-    elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif(re.findall(__upload_proto_support__, outfile)):
         fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
@@ -5418,7 +5621,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
         if(not infile):
             return False
         infile.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
+    elif(re.findall(__download_proto_support__, infile)):
         infile = download_file_from_internet_file(infile)
         infile.seek(0, 0)
         if(not infile):
@@ -5442,7 +5645,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
                 return False
     try:
         if(hasattr(infile, "read") or hasattr(infile, "write")):
-            compresscheck = CheckCompressionType(infile, formatspecs, False)
+            compresscheck = CheckCompressionType(infile, formatspecs, 0, False)
             if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
                 formatspecs = formatspecs[compresscheck]
             if(compresscheck=="zstd"):
@@ -5454,7 +5657,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
             else:
                 tarfp = tarfile.open(fileobj=infile, mode="r")
         else:
-            compresscheck = CheckCompressionType(infile, formatspecs, True)
+            compresscheck = CheckCompressionType(infile, formatspecs, 0, True)
             if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
                 formatspecs = formatspecs[compresscheck]
             if(compresscheck=="zstd"):
@@ -5555,9 +5758,9 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
             fpc = tarfp.extractfile(member)
             shutil.copyfileobj(fpc, fcontents)
             fpc.close()
-            typechecktest = CheckCompressionType(fcontents, closefp=False)
+            typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
             fcontents.seek(0, 0)
-            fcencoding = GetFileEncoding(fcontents, False)
+            fcencoding = GetFileEncoding(fcontents, 0, False)
             if(typechecktest is False and not compresswholefile):
                 fcontents.seek(0, 2)
                 ucfsize = fcontents.tell()
@@ -5635,7 +5838,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
         outvar = fp.read()
         fp.close()
         return outvar
-    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall(__upload_proto_support__, outfile)):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
@@ -5686,7 +5889,7 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
         fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
-    elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif(re.findall(__upload_proto_support__, outfile)):
         fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
@@ -5715,7 +5918,7 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
         if(not infile):
             return False
         infile.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
+    elif(re.findall(__download_proto_support__, infile)):
         infile = download_file_from_internet_file(infile)
         infile.seek(0, 0)
         if(not infile):
@@ -5852,9 +6055,9 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
         curcompression = "none"
         if ftype == 0:
             fcontents.write(zipfp.read(member.filename))
-            typechecktest = CheckCompressionType(fcontents, closefp=False)
+            typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
             fcontents.seek(0, 0)
-            fcencoding = GetFileEncoding(fcontents, False)
+            fcencoding = GetFileEncoding(fcontents, 0, False)
             if(typechecktest is False and not compresswholefile):
                 fcontents.seek(0, 2)
                 ucfsize = fcontents.tell()
@@ -5929,7 +6132,7 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
         outvar = fp.read()
         fp.close()
         return outvar
-    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall(__upload_proto_support__, outfile)):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
@@ -5985,7 +6188,7 @@ if(rarfile_support):
             fp = MkTempFile()
         elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
             fp = outfile
-        elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+        elif(re.findall(__upload_proto_support__, outfile)):
             fp = MkTempFile()
         else:
             fbasename = os.path.splitext(outfile)[0]
@@ -6169,9 +6372,9 @@ if(rarfile_support):
             curcompression = "none"
             if ftype == 0:
                 fcontents.write(rarfp.read(member.filename))
-                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
-                fcencoding = GetFileEncoding(fcontents, False)
+                fcencoding = GetFileEncoding(fcontents, 0, False)
                 if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
@@ -6249,7 +6452,7 @@ if(rarfile_support):
             outvar = fp.read()
             fp.close()
             return outvar
-        elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+        elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall(__upload_proto_support__, outfile)):
             fp = CompressOpenFileAlt(
                 fp, compression, compressionlevel, compressionuselist, formatspecs)
             fp.seek(0, 0)
@@ -6305,7 +6508,7 @@ if(py7zr_support):
             fp = MkTempFile()
         elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
             fp = outfile
-        elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+        elif(re.findall(__upload_proto_support__, outfile)):
             fp = MkTempFile()
         else:
             fbasename = os.path.splitext(outfile)[0]
@@ -6328,7 +6531,7 @@ if(py7zr_support):
             return False
         szpfp = py7zr.SevenZipFile(infile, mode="r")
         file_content = szpfp.readall()
-        #sztest = szpfp.testzip();
+        #sztest = szpfp.testzip()
         sztestalt = szpfp.test()
         if(sztestalt):
             VerbosePrintOut("Bad file found!")
@@ -6422,9 +6625,9 @@ if(py7zr_support):
                 fcontents.write(file_content[member.filename].read())
                 fsize = format(fcontents.tell(), 'x').lower()
                 fcontents.seek(0, 0)
-                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
-                fcencoding = GetFileEncoding(fcontents, False)
+                fcencoding = GetFileEncoding(fcontents, 0, False)
                 file_content[member.filename].close()
                 if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
@@ -6503,7 +6706,7 @@ if(py7zr_support):
             outvar = fp.read()
             fp.close()
             return outvar
-        elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+        elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall(__upload_proto_support__, outfile)):
             fp = CompressOpenFileAlt(
                 fp, compression, compressionlevel, compressionuselist, formatspecs)
             fp.seek(0, 0)
@@ -6517,7 +6720,7 @@ if(py7zr_support):
 
 
 def PackFoxFileFromInFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["crc32", "crc32", "crc32"], extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
-    checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+    checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
     if(verbose):
@@ -6537,18 +6740,20 @@ def PackFoxFileFromInFile(infile, outfile, fmttype="auto", compression="auto", c
     return False
 
 
-def FoxFileSeekToFileNum(infile, fmttype="auto", seekto=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+def FoxFileValidate(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
+    if(verbose):
+        logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
     if(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype in formatspecs):
         formatspecs = formatspecs[fmttype]
     elif(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype not in formatspecs):
         fmttype = "auto"
-    curloc = 0
+    curloc = filestart
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         curloc = infile.tell()
         fp = infile
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
@@ -6565,45 +6770,45 @@ def FoxFileSeekToFileNum(infile, fmttype="auto", seekto=0, listonly=False, conte
             return False
         if(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     elif(infile == "-"):
         fp = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, fp)
         else:
             shutil.copyfileobj(sys.stdin, fp)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         if(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
         fp = MkTempFile()
         fp.write(infile)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        compresscheck = CheckCompressionType(fp, formatspecs, 0, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         if(not fp):
             return False
-        fp.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
+        fp.seek(filestart, 0)
+    elif(re.findall(__download_proto_support__, infile)):
         fp = download_file_from_internet_file(infile)
-        fp = UncompressFileAlt(fp, formatspecs)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        compresscheck = CheckCompressionType(fp, formatspecs, 0, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
         if(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     else:
         infile = RemoveWindowsPath(infile)
-        checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+        checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
@@ -6618,7 +6823,7 @@ def FoxFileSeekToFileNum(infile, fmttype="auto", seekto=0, listonly=False, conte
             return False
         elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
             return False
-        compresscheck = CheckCompressionType(infile, formatspecs, True)
+        compresscheck = CheckCompressionType(infile, formatspecs, filestart, True)
         if(not compresscheck):
             fextname = os.path.splitext(infile)[1]
             if(fextname == ".gz"):
@@ -6641,26 +6846,23 @@ def FoxFileSeekToFileNum(infile, fmttype="auto", seekto=0, listonly=False, conte
                 return False
         if(not compresscheck):
             return False
-        fp = UncompressFile(infile, formatspecs, "rb")
+        fp = UncompressFile(infile, formatspecs, "rb", filestart)
     try:
-        fp.seek(0, 2);
+        fp.seek(0, 2)
     except OSError:
-        SeekToEndOfFile(fp);
+        SeekToEndOfFile(fp)
     except ValueError:
-        SeekToEndOfFile(fp);
-    CatSize = fp.tell();
-    CatSizeEnd = CatSize;
+        SeekToEndOfFile(fp)
+    CatSize = fp.tell()
+    CatSizeEnd = CatSize
     fp.seek(curloc, 0)
-    if(curloc > 0):
-        fp.seek(0, 0)
     if(IsNestedDict(formatspecs)):
-        compresschecking = CheckCompressionType(fp, formatspecs, False)
+        compresschecking = CheckCompressionType(fp, formatspecs, filestart, False)
         if(compresschecking not in formatspecs):
-            fp.seek(0, 0)
             return False
         else:
             formatspecs = formatspecs[compresschecking]
-            fp.seek(0, 0)
+            fp.seek(filestart, 0)
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
     formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
     formdelszie = len(formatspecs['format_delimiter'])
@@ -6677,23 +6879,8 @@ def FoxFileSeekToFileNum(infile, fmttype="auto", seekto=0, listonly=False, conte
             fp, formatspecs['format_delimiter'])
     fnumextrafieldsize = int(inheader[5], 16)
     fnumextrafields = int(inheader[6], 16)
-    fextrafieldslist = []
     extrastart = 7
     extraend = extrastart + fnumextrafields
-    while(extrastart < extraend):
-        fextrafieldslist.append(inheader[extrastart])
-        extrastart = extrastart + 1
-    if(fnumextrafields==1):
-        try:
-            fextrafieldslist = json.loads(base64.b64decode(fextrafieldslist[0]).decode("UTF-8"))
-            fnumextrafields = len(fextrafieldslist)
-        except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
-            try:
-                fextrafieldslist = json.loads(fextrafieldslist[0])
-            except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
-                pass
-    if(curloc > 0):
-        fp.seek(curloc, 0)
     formversion = re.findall("([\\d]+)", formstring)
     fheadsize = int(inheader[0], 16)
     fnumfields = int(inheader[1], 16)
@@ -6702,649 +6889,27 @@ def FoxFileSeekToFileNum(infile, fmttype="auto", seekto=0, listonly=False, conte
     fnumfiles = int(inheader[4], 16)
     fprechecksumtype = inheader[-2]
     fprechecksum = inheader[-1]
+    il = 0
     headercheck = ValidateHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, fprechecksum, formatspecs)
     newfcs = GetHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, True, formatspecs)
-    if(not headercheck and not skipchecksum):
-        VerbosePrintOut(
-            "File Header Checksum Error with file at offset " + str(0))
-        VerbosePrintOut("'" + fprechecksum + "' != " +
-                        "'" + newfcs + "'")
-        return False
-    formversions = re.search('(.*?)(\\d+)', formstring).groups()
-    fcompresstype = compresscheck
-    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(seekto >= fnumfiles):
-        seekto = fnumfiles - 1
-    if(seekto < 0):
-        seekto = 0
-    if(seekto >= 0):
-        il = -1
-        while (fp.tell() < CatSizeEnd) if seektoend else (il < seekto):
-            prefhstart = fp.tell()
-            if(formatspecs['new_style']):
-                preheaderdata = ReadFileHeaderDataBySize(
-                    fp, formatspecs['format_delimiter'])
-            else:
-                preheaderdata = ReadFileHeaderDataWoSize(
-                    fp, formatspecs['format_delimiter'])
-            if(len(preheaderdata) == 0):
-                break
-            prefheadsize = int(preheaderdata[0], 16)
-            prefnumfields = int(preheaderdata[1], 16)
-            preftype = int(preheaderdata[2], 16)
-            prefencoding = preheaderdata[3]
-            prefcencoding = preheaderdata[4]
-            if(re.findall("^[.|/]", preheaderdata[5])):
-                prefname = preheaderdata[5]
-            else:
-                prefname = "./"+preheaderdata[5]
-            prefbasedir = os.path.dirname(prefname)
-            preflinkname = preheaderdata[6]
-            prefsize = int(preheaderdata[7], 16)
-            prefatime = int(preheaderdata[8], 16)
-            prefmtime = int(preheaderdata[9], 16)
-            prefctime = int(preheaderdata[10], 16)
-            prefbtime = int(preheaderdata[11], 16)
-            prefmode = int(preheaderdata[12], 16)
-            prefchmode = stat.S_IMODE(prefmode)
-            preftypemod = stat.S_IFMT(prefmode)
-            prefwinattributes = int(preheaderdata[13], 16)
-            prefcompression = preheaderdata[14]
-            prefcsize = int(preheaderdata[15], 16)
-            prefuid = int(preheaderdata[16], 16)
-            prefuname = preheaderdata[17]
-            prefgid = int(preheaderdata[18], 16)
-            prefgname = preheaderdata[19]
-            fid = int(preheaderdata[20], 16)
-            finode = int(preheaderdata[21], 16)
-            flinkcount = int(preheaderdata[22], 16)
-            prefdev = int(preheaderdata[23], 16)
-            prefdev_minor = int(preheaderdata[24], 16)
-            prefdev_major = int(preheaderdata[25], 16)
-            prefseeknextfile = preheaderdata[26]
-            prefjsontype = preheaderdata[27]
-            prefjsonlen = int(preheaderdata[28], 16)
-            prefjsonsize = int(preheaderdata[29], 16)
-            prefjsonchecksumtype = preheaderdata[30]
-            prefjsonchecksum = preheaderdata[31]
-            prefhend = fp.tell() - 1
-            prefjstart = fp.tell()
-            prefjoutfprejsoncontent = fp.read(prefjsonsize).decode("UTF-8")
-            prefjend = fp.tell()
-            fp.seek(len(formatspecs['format_delimiter']), 1)
-            prejsonfcs = GetFileChecksum(prefjoutfprejsoncontent, prefjsonchecksumtype, True, formatspecs)
-            prefextrasize = int(preheaderdata[32], 16)
-            prefextrafields = int(preheaderdata[33], 16)
-            extrastart = 34
-            extraend = extrastart + prefextrafields
-            prefcs = preheaderdata[-2].lower()
-            prenewfcs = preheaderdata[-1].lower()
-            prenewfcs = GetHeaderChecksum(
-                preheaderdata[:-2], preheaderdata[-4].lower(), True, formatspecs)
-            if(prefcs != prenewfcs and not skipchecksum):
-                VerbosePrintOut("File Header Checksum Error with file " +
-                                prefname + " at offset " + str(prefhstart))
-                VerbosePrintOut("'" + prefcs + "' != " +
-                                "'" + prenewfcs + "'")
-                return False
-            if(prefjsonsize > 0):
-                if(prejsonfcs != prefjsonchecksum and not skipchecksum):
-                    VerbosePrintOut("File JSON Data Checksum Error with file " +
-                                    prefname + " at offset " + str(prefjstart))
-                    VerbosePrintOut("'" + prefjsonchecksum + "' != " + "'" + prejsonfcs + "'")
-                    return False
-            prefcontentstart = fp.tell()
-            prefcontents = ""
-            pyhascontents = False
-            if(prefsize > 0):
-                if(prefcompression):
-                    prefcontents = fp.read(prefsize)
-                else:
-                    prefcontents = fp.read(prefcsize)
-                prenewfccs = GetFileChecksum(
-                    prefcontents, preheaderdata[-3].lower(), False, formatspecs)
-                pyhascontents = True
-                if(prefccs != prenewfccs and not skipchecksum):
-                    VerbosePrintOut("File Content Checksum Error with file " +
-                                    prefname + " at offset " + str(prefcontentstart))
-                    VerbosePrintOut("'" + prefccs +
-                                    "' != " + "'" + prenewfccs + "'")
-                    return False
-            if(re.findall("^\\+([0-9]+)", prefseeknextfile)):
-                fseeknextasnum = int(prefseeknextfile.replace("+", ""))
-                if(abs(fseeknextasnum) == 0):
-                    pass
-                fp.seek(fseeknextasnum, 1)
-            elif(re.findall("^\\-([0-9]+)", prefseeknextfile)):
-                fseeknextasnum = int(prefseeknextfile)
-                if(abs(fseeknextasnum) == 0):
-                    pass
-                fp.seek(fseeknextasnum, 1)
-            elif(re.findall("^([0-9]+)", prefseeknextfile)):
-                fseeknextasnum = int(prefseeknextfile)
-                if(abs(fseeknextasnum) == 0):
-                    pass
-                fp.seek(fseeknextasnum, 0)
-            else:
-                return False
-            il = il + 1
-    fp.seek(seekstart, 0)
-    fileidnum = il
-    outfheadsize = int(preheaderdata[0], 16)
-    outfnumfields = int(preheaderdata[1], 16)
-    outftype = int(preheaderdata[2], 16)
-    outfencoding = preheaderdata[3]
-    if(re.findall("^[.|/]", preheaderdata[4])):
-        outfname = preheaderdata[4]
-    else:
-        outfname = "./"+preheaderdata[4]
-    outflinkname = preheaderdata[5]
-    outfsize = int(preheaderdata[6], 16)
-    outfbasedir = os.path.dirname(outfname)
-    outlist = {'fid': fileidnum, 'foffset': fp.tell(), 'ftype': outftype, 'fencoding': outfencoding, 'fname': outfname,
-               'fbasedir': outfbasedir, 'flinkname': outflinkname, 'fsize': outfsize}
-    if(returnfp):
-        outlist.update({'fp': fp})
-    else:
-        fp.close()
-    return outlist
-
-
-def FoxFileSeekToFileName(infile, fmttype="auto", seekfile=None, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
-    if(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype in formatspecs):
-        formatspecs = formatspecs[fmttype]
-    elif(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype not in formatspecs):
-        fmttype = "auto"
-    curloc = 0
-    if(hasattr(infile, "read") or hasattr(infile, "write")):
-        curloc = infile.tell()
-        fp = infile
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
-        if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
-            formatspecs = formatspecs[checkcompressfile]
-        if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-            return TarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
-            return ZipFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
-            return RarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
-            return SevenZipFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(IsSingleDict(formatspecs) and checkcompressfile != formatspecs['format_magic']):
-            return False
-        elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
-            return False
-        if(not fp):
-            return False
-        fp.seek(0, 0)
-    elif(infile == "-"):
-        fp = MkTempFile()
-        if(hasattr(sys.stdin, "buffer")):
-            shutil.copyfileobj(sys.stdin.buffer, fp)
-        else:
-            shutil.copyfileobj(sys.stdin, fp)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
-        if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
-            formatspecs = formatspecs[checkcompressfile]
-        if(not fp):
-            return False
-        fp.seek(0, 0)
-    elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
-        fp = MkTempFile()
-        fp.write(infile)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
-        if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
-            formatspecs = formatspecs[compresscheck]
-        if(not fp):
-            return False
-        fp.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
-        fp = download_file_from_internet_file(infile)
-        fp = UncompressFileAlt(fp, formatspecs)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
-        if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
-            formatspecs = formatspecs[compresscheck]
-        fp.seek(0, 0)
-        if(not fp):
-            return False
-        fp.seek(0, 0)
-    else:
-        infile = RemoveWindowsPath(infile)
-        checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
-        if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
-            formatspecs = formatspecs[checkcompressfile]
-        if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-            return TarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
-            return ZipFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
-            return RarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
-            return SevenZipFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(IsSingleDict(formatspecs) and checkcompressfile != formatspecs['format_magic']):
-            return False
-        elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
-            return False
-        compresscheck = CheckCompressionType(infile, formatspecs, True)
-        if(not compresscheck):
-            fextname = os.path.splitext(infile)[1]
-            if(fextname == ".gz"):
-                compresscheck = "gzip"
-            elif(fextname == ".bz2"):
-                compresscheck = "bzip2"
-            elif(fextname == ".zst"):
-                compresscheck = "zstd"
-            elif(fextname == ".lz4" or fextname == ".clz4"):
-                compresscheck = "lz4"
-            elif(fextname == ".lzo" or fextname == ".lzop"):
-                compresscheck = "lzo"
-            elif(fextname == ".lzma"):
-                compresscheck = "lzma"
-            elif(fextname == ".xz"):
-                compresscheck = "xz"
-            elif(fextname == ".zz" or fextname == ".zl" or fextname == ".zlib"):
-                compresscheck = "zlib"
-            else:
-                return False
-        if(not compresscheck):
-            return False
-        fp = UncompressFile(infile, formatspecs, "rb")
-    try:
-        fp.seek(0, 2);
-    except OSError:
-        SeekToEndOfFile(fp);
-    except ValueError:
-        SeekToEndOfFile(fp);
-    CatSize = fp.tell();
-    CatSizeEnd = CatSize;
-    fp.seek(curloc, 0)
-    if(curloc > 0):
-        fp.seek(0, 0)
-    if(IsNestedDict(formatspecs)):
-        compresschecking = CheckCompressionType(fp, formatspecs, False)
-        if(compresschecking not in formatspecs):
-            return False
-        else:
-            formatspecs = formatspecs[compresschecking]
-            fp.seek(0, 0)
-    inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
-    formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
-    formdelszie = len(formatspecs['format_delimiter'])
-    formdel = fp.read(formdelszie).decode("UTF-8")
-    if(formstring != formatspecs['format_magic']+inheaderver):
-        return False
-    if(formdel != formatspecs['format_delimiter']):
-        return False
-    if(formatspecs['new_style']):
-        inheader = ReadFileHeaderDataBySize(
-            fp, formatspecs['format_delimiter'])
-    else:
-        inheader = ReadFileHeaderDataWoSize(
-            fp, formatspecs['format_delimiter'])
-    fnumextrafieldsize = int(inheader[5], 16)
-    fnumextrafields = int(inheader[6], 16)
-    fextrafieldslist = []
-    extrastart = 7
-    extraend = extrastart + fnumextrafields
-    while(extrastart < extraend):
-        fextrafieldslist.append(inheader[extrastart])
-        extrastart = extrastart + 1
-    if(fnumextrafields==1):
-        try:
-            fextrafieldslist = json.loads(base64.b64decode(fextrafieldslist[0]).decode("UTF-8"))
-            fnumextrafields = len(fextrafieldslist)
-        except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
-            try:
-                fextrafieldslist = json.loads(fextrafieldslist[0])
-            except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
-                pass
-    if(curloc > 0):
-        fp.seek(curloc, 0)
-    formversion = re.findall("([\\d]+)", formstring)
-    fheadsize = int(inheader[0], 16)
-    fnumfields = int(inheader[1], 16)
-    fhencoding = inheader[2]
-    fostype = inheader[3]
-    fnumfiles = int(inheader[4], 16)
-    fprechecksumtype = inheader[-2]
-    fprechecksum = inheader[-1]
-    headercheck = ValidateHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, fprechecksum, formatspecs)
-    newfcs = GetHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, True, formatspecs)
-    if(not headercheck and not skipchecksum):
-        VerbosePrintOut(
-            "File Header Checksum Error with file at offset " + str(0))
-        VerbosePrintOut("'" + fprechecksum + "' != " +
-                        "'" + newfcs + "'")
-        return False
-    formversions = re.search('(.*?)(\\d+)', formstring).groups()
-    fcompresstype = compresscheck
-    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': []}
-    seekto = fnumfiles - 1
-    filefound = False
-    if(seekto >= 0):
-        il = -1
-        while (fp.tell() < CatSizeEnd) if seektoend else (il < seekto):
-            prefhstart = fp.tell()
-            if(formatspecs['new_style']):
-                preheaderdata = ReadFileHeaderDataBySize(
-                    fp, formatspecs['format_delimiter'])
-            else:
-                preheaderdata = ReadFileHeaderDataWoSize(
-                    fp, formatspecs['format_delimiter'])
-            if(len(preheaderdata) == 0):
-                break
-            prefheadsize = int(preheaderdata[0], 16)
-            prefnumfields = int(preheaderdata[1], 16)
-            preftype = int(preheaderdata[2], 16)
-            prefencoding = preheaderdata[3]
-            prefencoding = preheaderdata[4]
-            if(re.findall("^[.|/]", preheaderdata[5])):
-                prefname = preheaderdata[5]
-            else:
-                prefname = "./"+preheaderdata[5]
-            prefbasedir = os.path.dirname(prefname)
-            preflinkname = preheaderdata[6]
-            prefsize = int(preheaderdata[7], 16)
-            prefatime = int(preheaderdata[8], 16)
-            prefmtime = int(preheaderdata[9], 16)
-            prefctime = int(preheaderdata[10], 16)
-            prefbtime = int(preheaderdata[11], 16)
-            prefmode = int(preheaderdata[12], 16)
-            prefchmode = stat.S_IMODE(prefmode)
-            preftypemod = stat.S_IFMT(prefmode)
-            prefwinattributes = int(preheaderdata[13], 16)
-            prefcompression = preheaderdata[14]
-            prefcsize = int(preheaderdata[15], 16)
-            prefuid = int(preheaderdata[16], 16)
-            prefuname = preheaderdata[17]
-            prefgid = int(preheaderdata[18], 16)
-            prefgname = preheaderdata[19]
-            fid = int(preheaderdata[20], 16)
-            finode = int(preheaderdata[21], 16)
-            flinkcount = int(preheaderdata[22], 16)
-            prefdev = int(preheaderdata[23], 16)
-            prefdev_minor = int(preheaderdata[24], 16)
-            prefdev_major = int(preheaderdata[25], 16)
-            prefseeknextfile = preheaderdata[26]
-            prefjsontype = preheaderdata[27]
-            prefjsonlen = int(preheaderdata[28], 16)
-            prefjsonsize = int(preheaderdata[29], 16)
-            prefjsonchecksumtype = preheaderdata[30]
-            prefjsonchecksum = preheaderdata[31]
-            prefhend = fp.tell() - 1
-            prefjstart = fp.tell()
-            prefjoutfprejsoncontent = fp.read(prefjsonsize).decode("UTF-8")
-            prefjend = fp.tell()
-            fp.seek(len(formatspecs['format_delimiter']), 1)
-            prejsonfcs = GetFileChecksum(prefjoutfprejsoncontent, prefjsonchecksumtype, True, formatspecs)
-            prefextrasize = int(preheaderdata[32], 16)
-            prefextrafields = int(preheaderdata[33], 16)
-            extrastart = 34
-            extraend = extrastart + prefextrafields
-            prefcs = preheaderdata[-2].lower()
-            prenewfcs = preheaderdata[-1].lower()
-            prenewfcs = GetHeaderChecksum(
-                preheaderdata[:-2], preheaderdata[-4].lower(), True, formatspecs)
-            if(prefcs != prenewfcs and not skipchecksum):
-                VerbosePrintOut("File Header Checksum Error with file " +
-                                prefname + " at offset " + str(prefhstart))
-                VerbosePrintOut("'" + prefcs + "' != " +
-                                "'" + prenewfcs + "'")
-                return False
-            if(prefjsonsize > 0):
-                if(prejsonfcs != prefjsonchecksum and not skipchecksum):
-                    VerbosePrintOut("File JSON Data Checksum Error with file " +
-                                    prefname + " at offset " + str(prefjstart))
-                    VerbosePrintOut("'" + prefjsonchecksum + "' != " + "'" + prejsonfcs + "'")
-                    return False
-            prefcontentstart = fp.tell()
-            prefcontents = ""
-            pyhascontents = False
-            if(prefsize > 0):
-                if(prefcompression):
-                    prefcontents = fp.read(prefsize)
-                else:
-                    prefcontents = fp.read(prefcsize)
-                prenewfccs = GetFileChecksum(
-                    prefcontents, preheaderdata[-3].lower(), False, formatspecs)
-                pyhascontents = True
-                if(prefccs != prenewfccs and not skipchecksum):
-                    VerbosePrintOut("File Content Checksum Error with file " +
-                                    prefname + " at offset " + str(prefcontentstart))
-                    VerbosePrintOut("'" + prefccs +
-                                    "' != " + "'" + prenewfccs + "'")
-                    return False
-            if(re.findall("^\\+([0-9]+)", prefseeknextfile)):
-                fseeknextasnum = int(prefseeknextfile.replace("+", ""))
-                if(abs(fseeknextasnum) == 0):
-                    pass
-                fp.seek(fseeknextasnum, 1)
-            elif(re.findall("^\\-([0-9]+)", prefseeknextfile)):
-                fseeknextasnum = int(prefseeknextfile)
-                if(abs(fseeknextasnum) == 0):
-                    pass
-                fp.seek(fseeknextasnum, 1)
-            elif(re.findall("^([0-9]+)", prefseeknextfile)):
-                fseeknextasnum = int(prefseeknextfile)
-                if(abs(fseeknextasnum) == 0):
-                    pass
-                fp.seek(fseeknextasnum, 0)
-            else:
-                return False
-            il = il + 1
-            filefound = False
-            if(prefname == seekfile):
-                filefound = True
-                break
-    fp.seek(seekstart, 0)
-    fileidnum = il
-    outfheadsize = int(preheaderdata[0], 16)
-    outfnumfields = int(preheaderdata[1], 16)
-    outftype = int(preheaderdata[2], 16)
-    outfencoding = preheaderdata[3]
-    if(re.findall("^[.|/]", preheaderdata[4])):
-        outfname = preheaderdata[4]
-    else:
-        outfname = "./"+preheaderdata[4]
-    outflinkname = preheaderdata[5]
-    outfsize = int(preheaderdata[6], 16)
-    outfbasedir = os.path.dirname(outfname)
-    if(filefound):
-        outlist = {'fid': fileidnum, 'foffset': fp.tell(), 'ftype': outftype, 'fencoding': outfencoding, 'fname': outfname,
-                   'fbasedir': outfbasedir, 'flinkname': outflinkname, 'fsize': outfsize}
-    else:
-        return False
-    if(returnfp):
-        outlist.update({'fp': fp})
-    else:
-        fp.close()
-    return outlist
-
-
-def FoxFileValidate(infile, fmttype="auto", formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
-    if(verbose):
-        logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
-    if(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype in formatspecs):
-        formatspecs = formatspecs[fmttype]
-    elif(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype not in formatspecs):
-        fmttype = "auto"
-    curloc = 0
-    if(hasattr(infile, "read") or hasattr(infile, "write")):
-        curloc = infile.tell()
-        fp = infile
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
-        if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
-            formatspecs = formatspecs[checkcompressfile]
-        if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-            return TarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
-            return ZipFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
-            return RarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
-            return SevenZipFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(IsSingleDict(formatspecs) and checkcompressfile != formatspecs['format_magic']):
-            return False
-        elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
-            return False
-        if(not fp):
-            return False
-        fp.seek(0, 0)
-    elif(infile == "-"):
-        fp = MkTempFile()
-        if(hasattr(sys.stdin, "buffer")):
-            shutil.copyfileobj(sys.stdin.buffer, fp)
-        else:
-            shutil.copyfileobj(sys.stdin, fp)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
-        if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
-            formatspecs = formatspecs[checkcompressfile]
-        if(not fp):
-            return False
-        fp.seek(0, 0)
-    elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
-        fp = MkTempFile()
-        fp.write(infile)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
-        if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
-            formatspecs = formatspecs[compresscheck]
-        if(not fp):
-            return False
-        fp.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
-        fp = download_file_from_internet_file(infile)
-        fp = UncompressFileAlt(fp, formatspecs)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
-        if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
-            formatspecs = formatspecs[compresscheck]
-        fp.seek(0, 0)
-        if(not fp):
-            return False
-        fp.seek(0, 0)
-    else:
-        infile = RemoveWindowsPath(infile)
-        checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
-        if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
-            formatspecs = formatspecs[checkcompressfile]
-        if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-            return TarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
-            return ZipFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
-            return RarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
-            return SevenZipFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(IsSingleDict(formatspecs) and checkcompressfile != formatspecs['format_magic']):
-            return False
-        elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
-            return False
-        compresscheck = CheckCompressionType(infile, formatspecs, True)
-        if(not compresscheck):
-            fextname = os.path.splitext(infile)[1]
-            if(fextname == ".gz"):
-                compresscheck = "gzip"
-            elif(fextname == ".bz2"):
-                compresscheck = "bzip2"
-            elif(fextname == ".zst"):
-                compresscheck = "zstd"
-            elif(fextname == ".lz4" or fextname == ".clz4"):
-                compresscheck = "lz4"
-            elif(fextname == ".lzo" or fextname == ".lzop"):
-                compresscheck = "lzo"
-            elif(fextname == ".lzma"):
-                compresscheck = "lzma"
-            elif(fextname == ".xz"):
-                compresscheck = "xz"
-            elif(fextname == ".zz" or fextname == ".zl" or fextname == ".zlib"):
-                compresscheck = "zlib"
-            else:
-                return False
-        if(not compresscheck):
-            return False
-        fp = UncompressFile(infile, formatspecs, "rb")
-    try:
-        fp.seek(0, 2);
-    except OSError:
-        SeekToEndOfFile(fp);
-    except ValueError:
-        SeekToEndOfFile(fp);
-    CatSize = fp.tell();
-    CatSizeEnd = CatSize;
-    fp.seek(curloc, 0)
-    if(curloc > 0):
-        fp.seek(0, 0)
-    if(IsNestedDict(formatspecs)):
-        compresschecking = CheckCompressionType(fp, formatspecs, False)
-        if(compresschecking not in formatspecs):
-            return False
-        else:
-            formatspecs = formatspecs[compresschecking]
-            fp.seek(0, 0)
-    inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
-    formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
-    formdelszie = len(formatspecs['format_delimiter'])
-    formdel = fp.read(formdelszie).decode("UTF-8")
-    if(formstring != formatspecs['format_magic']+inheaderver):
-        return False
-    if(formdel != formatspecs['format_delimiter']):
-        return False
-    if(formatspecs['new_style']):
-        inheader = ReadFileHeaderDataBySize(
-            fp, formatspecs['format_delimiter'])
-    else:
-        inheader = ReadFileHeaderDataWoSize(
-            fp, formatspecs['format_delimiter'])
-    fnumextrafieldsize = int(inheader[5], 16)
-    fnumextrafields = int(inheader[6], 16)
-    extrastart = 7
-    extraend = extrastart + fnumextrafields
-    if(curloc > 0):
-        fp.seek(curloc, 0)
-    formversion = re.findall("([\\d]+)", formstring)
-    fheadsize = int(inheader[0], 16)
-    fnumfields = int(inheader[1], 16)
-    fhencoding = inheader[2]
-    fostype = inheader[3]
-    fnumfiles = int(inheader[4], 16)
-    fprechecksumtype = inheader[-2]
-    fprechecksum = inheader[-1]
-    il = 0
-    headercheck = ValidateHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, fprechecksum, formatspecs)
-    newfcs = GetHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, True, formatspecs)
-    valid_archive = True
-    invalid_archive = False
-    if(verbose):
-        if(hasattr(infile, "read") or hasattr(infile, "write")):
-            try:
-                VerbosePrintOut(infile.name)
-            except AttributeError:
-                pass
-        elif(sys.version_info[0] >= 3 and isinstance(infile, bytes)):
-            pass
-        else:
-            VerbosePrintOut(infile)
-        VerbosePrintOut("Number of Records " + str(fnumfiles))
-    if(headercheck):
-        if(verbose):
-            VerbosePrintOut("File Header Checksum Passed at offset " + str(0))
-            VerbosePrintOut("'" + fprechecksum + "' == " +
-                            "'" + newfcs + "'")
+    valid_archive = True
+    invalid_archive = False
+    if(verbose):
+        if(hasattr(infile, "read") or hasattr(infile, "write")):
+            try:
+                VerbosePrintOut(infile.name)
+            except AttributeError:
+                pass
+        elif(sys.version_info[0] >= 3 and isinstance(infile, bytes)):
+            pass
+        else:
+            VerbosePrintOut(infile)
+        VerbosePrintOut("Number of Records " + str(fnumfiles))
+    if(headercheck):
+        if(verbose):
+            VerbosePrintOut("File Header Checksum Passed at offset " + str(0))
+            VerbosePrintOut("'" + fprechecksum + "' == " +
+                            "'" + newfcs + "'")
     else:
         if(verbose):
             VerbosePrintOut("File Header Checksum Failed at offset " + str(0))
@@ -7525,18 +7090,18 @@ def FoxFileValidateMultiple(infile, fmttype="auto", formatspecs=__file_format_mu
 def FoxFileValidateMultipleFiles(infile, fmttype="auto", formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
     return FoxFileValidateMultiple(infile, fmttype, formatspecs, verbose, returnfp)
 
-def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+def FoxFileToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
     if(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype in formatspecs):
         formatspecs = formatspecs[fmttype]
     elif(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype not in formatspecs):
         fmttype = "auto"
-    curloc = 0
+    curloc = filestart
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         curloc = infile.tell()
         fp = infile
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
@@ -7553,45 +7118,45 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
             return False
         if(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     elif(infile == "-"):
         fp = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, fp)
         else:
             shutil.copyfileobj(sys.stdin, fp)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         if(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
         fp = MkTempFile()
         fp.write(infile)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         if(not fp):
             return False
-        fp.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
+        fp.seek(filestart, 0)
+    elif(re.findall(__download_proto_support__, infile)):
         fp = download_file_from_internet_file(infile)
-        fp = UncompressFileAlt(fp, formatspecs)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
         if(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     else:
         infile = RemoveWindowsPath(infile)
-        checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+        checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
@@ -7606,7 +7171,7 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
             return False
         elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
             return False
-        compresscheck = CheckCompressionType(infile, formatspecs, True)
+        compresscheck = CheckCompressionType(infile, formatspecs, filestart, True)
         if(not compresscheck):
             fextname = os.path.splitext(infile)[1]
             if(fextname == ".gz"):
@@ -7629,25 +7194,23 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
                 return False
         if(not compresscheck):
             return False
-        fp = UncompressFile(infile, formatspecs, "rb")
+        fp = UncompressFile(infile, formatspecs, "rb", filestart)
     try:
-        fp.seek(0, 2);
+        fp.seek(0, 2)
     except OSError:
-        SeekToEndOfFile(fp);
+        SeekToEndOfFile(fp)
     except ValueError:
-        SeekToEndOfFile(fp);
-    CatSize = fp.tell();
+        SeekToEndOfFile(fp)
+    CatSize = fp.tell()
     CatSizeEnd = CatSize;
     fp.seek(curloc, 0)
-    if(curloc > 0):
-        fp.seek(0, 0)
     if(IsNestedDict(formatspecs)):
-        compresschecking = CheckCompressionType(fp, formatspecs, False)
+        compresschecking = CheckCompressionType(fp, formatspecs, filestart, False)
         if(compresschecking not in formatspecs):
             return False
         else:
             formatspecs = formatspecs[compresschecking]
-            fp.seek(0, 0)
+            fp.seek(filestart, 0)
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
     formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
     formdelszie = len(formatspecs['format_delimiter'])
@@ -7679,8 +7242,6 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
                 fextrafieldslist = json.loads(fextrafieldslist[0])
             except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                 pass
-    if(curloc > 0):
-        fp.seek(curloc, 0)
     formversion = re.findall("([\\d]+)", formstring)
     fheadsize = int(inheader[0], 16)
     fnumfields = int(inheader[1], 16)
@@ -7701,7 +7262,7 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
     fcompresstype = compresscheck
     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': []}
+    outlist = {'fnumfiles': fnumfiles, 'ffilestart': filestart, '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) or (seekstart > fnumfiles):
         seekstart = 0
     if (seekend == 0) or (seekend > fnumfiles) or (seekend < seekstart):
@@ -7945,7 +7506,7 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
                 outfcontents.seek(0, 0)
                 if(uncompress):
                     cfcontents = UncompressFileAlt(
-                        outfcontents, formatspecs)
+                        outfcontents, formatspecs, 0)
                     cfcontents.seek(0, 0)
                     outfcontents = MkTempFile()
                     shutil.copyfileobj(cfcontents, outfcontents)
@@ -7990,49 +7551,49 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
     return outlist
 
 
-def MultipleFoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+def MultipleFoxFileToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
     if(isinstance(infile, (list, tuple, ))):
         pass
     else:
         infile = [infile]
     outretval = {}
     for curfname in infile:
-        curretfile[curfname] = FoxFileToArray(curfname, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
+        curretfile[curfname] = FoxFileToArray(curfname, fmttype, filestart, 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):
-    return MultipleFoxFileToArray(infile, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
+def MultipleFoxFilesToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+    return MultipleFoxFileToArray(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
 
 
-def FoxFileStringToArray(instr, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
-    checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+def FoxFileStringToArray(instr, filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+    checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
     fp = MkTempFile(instr)
-    listfoxfiles = FoxFileToArray(fp, "auto", seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
-    return listfoxfiles
+    listarrayfiles = FoxFileToArray(fp, "auto", filestart, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+    return listarrayfiles
 
 
 def TarFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False, returnfp=False):
-    checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+    checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
     fp = MkTempFile()
     fp = PackFoxFileFromTarFile(
         infile, fp, "auto", True, None, compressionlistalt, "crc32", [], formatspecs, False, True)
-    listfoxfiles = FoxFileToArray(fp, "auto", seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
-    return listfoxfiles
+    listarrayfiles = FoxFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+    return listarrayfiles
 
 
 def ZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False, returnfp=False):
-    checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+    checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
     fp = MkTempFile()
     fp = PackFoxFileFromZipFile(
         infile, fp, "auto", True, None, compressionlistalt, "crc32", [], formatspecs, False, True)
-    listfoxfiles = FoxFileToArray(fp, "auto", seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
-    return listfoxfiles
+    listarrayfiles = FoxFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+    return listarrayfiles
 
 
 if(not rarfile_support):
@@ -8041,14 +7602,14 @@ if(not rarfile_support):
 
 if(rarfile_support):
     def RarFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False, returnfp=False):
-        checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+        checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         fp = MkTempFile()
         fp = PackFoxFileFromRarFile(
             infile, fp, "auto", True, None, compressionlistalt, "crc32", [], formatspecs, False, True)
-        listfoxfiles = FoxFileToArray(fp, "auto", seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
-        return listfoxfiles
+        listarrayfiles = FoxFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+        return listarrayfiles
 
 if(not py7zr_support):
     def SevenZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False, returnfp=False):
@@ -8056,18 +7617,18 @@ if(not py7zr_support):
 
 if(py7zr_support):
     def SevenZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False, returnfp=False):
-        checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+        checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         fp = MkTempFile()
         fp = PackFoxFileFromSevenZipFile(
             infile, fp, "auto", True, None, compressionlistalt, "crc32", [], formatspecs, False, True)
-        listfoxfiles = FoxFileToArray(fp, "auto", seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
-        return listfoxfiles
+        listarrayfiles = FoxFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+        return listarrayfiles
 
 
-def InFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
-    checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+def InFileToArray(infile, filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+    checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
     if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
@@ -8079,78 +7640,78 @@ def InFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=
     elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
         return SevenZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
     elif(checkcompressfile == formatspecs['format_magic']):
-        return FoxFileToArray(infile, "auto", seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+        return FoxFileToArray(infile, "auto", filestart, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
     else:
         return False
     return False
 
 
-def ListDirToArray(infiles, dirlistfromtxt=False, fmttype=__file_format_default__, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, seekstart=0, seekend=0, listonly=False, skipchecksum=False, checksumtype=["crc32", "crc32", "crc32"], extradata=[], formatspecs=__file_format_dict__, verbose=False, seektoend=False, returnfp=False):
+def ListDirToArray(infiles, dirlistfromtxt=False, fmttype=__file_format_default__, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, filestart=0, seekstart=0, seekend=0, listonly=False, skipchecksum=False, checksumtype=["crc32", "crc32", "crc32"], extradata=[], formatspecs=__file_format_dict__, verbose=False, seektoend=False, returnfp=False):
     outarray = MkTempFile()
     packform = PackFoxFile(infiles, outarray, dirlistfromtxt, fmttype, compression, compresswholefile,
                               compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, True)
-    listfoxfiles = FoxFileToArray(outarray, "auto", seekstart, seekend, listonly, True, skipchecksum, formatspecs, seektoend, returnfp)
-    return listfoxfiles
+    listarrayfiles = FoxFileToArray(outarray, "auto", filestart, seekstart, seekend, listonly, True, skipchecksum, formatspecs, seektoend, returnfp)
+    return listarrayfiles
 
 
 def FoxFileArrayToArrayIndex(inarray, returnfp=False):
     if(isinstance(inarray, dict)):
-        listfoxfiles = inarray
+        listarrayfiles = inarray
     else:
         return False
-    if(not listfoxfiles):
+    if(not listarrayfiles):
         return False
-    outarray = {'list': listfoxfiles, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {
+    outarray = {'list': listarrayfiles, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {
     }, 'idtofile': {}}, 'hardlinks': {'filetoid': {}, 'idtofile': {}}, 'character': {'filetoid': {}, 'idtofile': {}}, 'block': {'filetoid': {}, 'idtofile': {}}, 'fifo': {'filetoid': {}, 'idtofile': {}}, 'devices': {'filetoid': {}, 'idtofile': {}}}}
     if(returnfp):
-        outarray.update({'fp': listfoxfiles['fp']})
-    lenlist = len(listfoxfiles['ffilelist'])
+        outarray.update({'fp': listarrayfiles['fp']})
+    lenlist = len(listarrayfiles['ffilelist'])
     lcfi = 0
-    lcfx = int(listfoxfiles['fnumfiles'])
-    if(lenlist > listfoxfiles['fnumfiles'] or lenlist < listfoxfiles['fnumfiles']):
+    lcfx = int(listarrayfiles['fnumfiles'])
+    if(lenlist > listarrayfiles['fnumfiles'] or lenlist < listarrayfiles['fnumfiles']):
         lcfx = int(lenlist)
     else:
-        lcfx = int(listfoxfiles['fnumfiles'])
+        lcfx = int(listarrayfiles['fnumfiles'])
     while(lcfi < lcfx):
-        filetoidarray = {listfoxfiles['ffilelist'][lcfi]
-                         ['fname']: listfoxfiles['ffilelist'][lcfi]['fid']}
-        idtofilearray = {listfoxfiles['ffilelist'][lcfi]
-                         ['fid']: listfoxfiles['ffilelist'][lcfi]['fname']}
+        filetoidarray = {listarrayfiles['ffilelist'][lcfi]
+                         ['fname']: listarrayfiles['ffilelist'][lcfi]['fid']}
+        idtofilearray = {listarrayfiles['ffilelist'][lcfi]
+                         ['fid']: listarrayfiles['ffilelist'][lcfi]['fname']}
         outarray['filetoid'].update(filetoidarray)
         outarray['idtofile'].update(idtofilearray)
-        if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 0 or listfoxfiles['ffilelist'][lcfi]['ftype'] == 7):
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 0 or listarrayfiles['ffilelist'][lcfi]['ftype'] == 7):
             outarray['filetypes']['files']['filetoid'].update(filetoidarray)
             outarray['filetypes']['files']['idtofile'].update(idtofilearray)
-        if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 1):
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 1):
             outarray['filetypes']['hardlinks']['filetoid'].update(
                 filetoidarray)
             outarray['filetypes']['hardlinks']['idtofile'].update(
                 idtofilearray)
             outarray['filetypes']['links']['filetoid'].update(filetoidarray)
             outarray['filetypes']['links']['idtofile'].update(idtofilearray)
-        if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 2):
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 2):
             outarray['filetypes']['symlinks']['filetoid'].update(filetoidarray)
             outarray['filetypes']['symlinks']['idtofile'].update(idtofilearray)
             outarray['filetypes']['links']['filetoid'].update(filetoidarray)
             outarray['filetypes']['links']['idtofile'].update(idtofilearray)
-        if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 3):
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 3):
             outarray['filetypes']['character']['filetoid'].update(
                 filetoidarray)
             outarray['filetypes']['character']['idtofile'].update(
                 idtofilearray)
             outarray['filetypes']['devices']['filetoid'].update(filetoidarray)
             outarray['filetypes']['devices']['idtofile'].update(idtofilearray)
-        if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 4):
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 4):
             outarray['filetypes']['block']['filetoid'].update(filetoidarray)
             outarray['filetypes']['block']['idtofile'].update(idtofilearray)
             outarray['filetypes']['devices']['filetoid'].update(filetoidarray)
             outarray['filetypes']['devices']['idtofile'].update(idtofilearray)
-        if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 5):
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 5):
             outarray['filetypes']['directories']['filetoid'].update(
                 filetoidarray)
             outarray['filetypes']['directories']['idtofile'].update(
                 idtofilearray)
-        if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 6):
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 6):
             outarray['filetypes']['symlinks']['filetoid'].update(filetoidarray)
             outarray['filetypes']['symlinks']['idtofile'].update(idtofilearray)
             outarray['filetypes']['devices']['filetoid'].update(filetoidarray)
@@ -8159,13 +7720,13 @@ def FoxFileArrayToArrayIndex(inarray, returnfp=False):
     return outarray
 
 
-def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, seekstart=0, seekend=0, checksumtype=["crc32", "crc32", "crc32", "crc32"], skipchecksum=False, extradata=[], jsondata={}, formatspecs=__file_format_dict__, seektoend=False, verbose=False, returnfp=False):
+def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, filestart=0, seekstart=0, seekend=0, checksumtype=["crc32", "crc32", "crc32", "crc32"], skipchecksum=False, extradata=[], jsondata={}, formatspecs=__file_format_dict__, seektoend=False, verbose=False, returnfp=False):
     if(isinstance(infile, dict)):
-        listfoxfiles = infile
+        listarrayfiles = infile
     else:
         if(infile != "-" and not isinstance(infile, bytes) and not hasattr(infile, "read") and not hasattr(infile, "write")):
             infile = RemoveWindowsPath(infile)
-        listfoxfiles = FoxFileToArray(infile, "auto", seekstart, seekend, False, True, skipchecksum, formatspecs, seektoend, returnfp)
+        listarrayfiles = FoxFileToArray(infile, "auto", filestart, seekstart, seekend, False, True, skipchecksum, formatspecs, seektoend, returnfp)
     if(IsNestedDict(formatspecs) and fmttype in formatspecs):
         formatspecs = formatspecs[fmttype]
     elif(IsNestedDict(formatspecs) and fmttype not in formatspecs):
@@ -8191,14 +7752,14 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                 os.unlink(outfile)
             except OSError:
                 pass
-    if(not listfoxfiles):
+    if(not listarrayfiles):
         return False
     if(outfile == "-" or outfile is None):
         verbose = False
         fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
-    elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif(re.findall(__upload_proto_support__, outfile)):
         fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
@@ -8211,19 +7772,19 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
             return False
     formver = formatspecs['format_ver']
     fileheaderver = str(int(formver.replace(".", "")))
-    lenlist = len(listfoxfiles['ffilelist'])
-    fnumfiles = int(listfoxfiles['fnumfiles'])
+    lenlist = len(listarrayfiles['ffilelist'])
+    fnumfiles = int(listarrayfiles['fnumfiles'])
     if(lenlist > fnumfiles or lenlist < fnumfiles):
         fnumfiles = lenlist
-    AppendFileHeader(fp, fnumfiles, listfoxfiles['fencoding'], [], checksumtype[0], formatspecs)
-    lenlist = len(listfoxfiles['ffilelist'])
-    fnumfiles = int(listfoxfiles['fnumfiles'])
+    AppendFileHeader(fp, fnumfiles, listarrayfiles['fencoding'], [], checksumtype[0], formatspecs)
+    lenlist = len(listarrayfiles['ffilelist'])
+    fnumfiles = int(listarrayfiles['fnumfiles'])
     lcfi = 0
-    lcfx = int(listfoxfiles['fnumfiles'])
-    if(lenlist > listfoxfiles['fnumfiles'] or lenlist < listfoxfiles['fnumfiles']):
+    lcfx = int(listarrayfiles['fnumfiles'])
+    if(lenlist > listarrayfiles['fnumfiles'] or lenlist < listarrayfiles['fnumfiles']):
         lcfx = int(lenlist)
     else:
-        lcfx = int(listfoxfiles['fnumfiles'])
+        lcfx = int(listarrayfiles['fnumfiles'])
     curinode = 0
     curfid = 0
     inodelist = []
@@ -8231,66 +7792,66 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
     filetoinode = {}
     reallcfi = 0
     while(lcfi < lcfx):
-        fencoding = listfoxfiles['ffilelist'][reallcfi]['fencoding']
-        fcencoding = listfoxfiles['ffilelist'][reallcfi]['fencoding']
-        if(re.findall("^[.|/]", listfoxfiles['ffilelist'][reallcfi]['fname'])):
-            fname = listfoxfiles['ffilelist'][reallcfi]['fname']
+        fencoding = listarrayfiles['ffilelist'][reallcfi]['fencoding']
+        fcencoding = listarrayfiles['ffilelist'][reallcfi]['fencoding']
+        if(re.findall("^[.|/]", listarrayfiles['ffilelist'][reallcfi]['fname'])):
+            fname = listarrayfiles['ffilelist'][reallcfi]['fname']
         else:
-            fname = "./"+listfoxfiles['ffilelist'][reallcfi]['fname']
+            fname = "./"+listarrayfiles['ffilelist'][reallcfi]['fname']
         if(verbose):
             VerbosePrintOut(fname)
         fheadersize = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fheadersize']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fheadersize']), 'x').lower()
         fsize = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fsize']), 'x').lower()
-        flinkname = listfoxfiles['ffilelist'][reallcfi]['flinkname']
+            int(listarrayfiles['ffilelist'][reallcfi]['fsize']), 'x').lower()
+        flinkname = listarrayfiles['ffilelist'][reallcfi]['flinkname']
         fatime = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fatime']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fatime']), 'x').lower()
         fmtime = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fmtime']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fmtime']), 'x').lower()
         fctime = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fctime']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fctime']), 'x').lower()
         fbtime = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fbtime']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fbtime']), 'x').lower()
         fmode = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fmode']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fmode']), 'x').lower()
         fchmode = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fchmode']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fchmode']), 'x').lower()
         fuid = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fuid']), 'x').lower()
-        funame = listfoxfiles['ffilelist'][reallcfi]['funame']
+            int(listarrayfiles['ffilelist'][reallcfi]['fuid']), 'x').lower()
+        funame = listarrayfiles['ffilelist'][reallcfi]['funame']
         fgid = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fgid']), 'x').lower()
-        fgname = listfoxfiles['ffilelist'][reallcfi]['fgname']
+            int(listarrayfiles['ffilelist'][reallcfi]['fgid']), 'x').lower()
+        fgname = listarrayfiles['ffilelist'][reallcfi]['fgname']
         finode = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['finode']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['finode']), 'x').lower()
         flinkcount = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['flinkcount']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['flinkcount']), 'x').lower()
         fwinattributes = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fwinattributes']), 'x').lower()
-        fcompression = listfoxfiles['ffilelist'][reallcfi]['fcompression']
+            int(listarrayfiles['ffilelist'][reallcfi]['fwinattributes']), 'x').lower()
+        fcompression = listarrayfiles['ffilelist'][reallcfi]['fcompression']
         fcsize = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fcsize']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fcsize']), 'x').lower()
         fdev = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fdev']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fdev']), 'x').lower()
         fdev_minor = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fminor']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fminor']), 'x').lower()
         fdev_major = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fmajor']), 'x').lower()
-        fseeknextfile = listfoxfiles['ffilelist'][reallcfi]['fseeknextfile']
-        if(len(listfoxfiles['ffilelist'][reallcfi]['fextralist']) > listfoxfiles['ffilelist'][reallcfi]['fextrafields'] and len(listfoxfiles['ffilelist'][reallcfi]['fextralist']) > 0):
-            listfoxfiles['ffilelist'][reallcfi]['fextrafields'] = len(
-                listfoxfiles['ffilelist'][reallcfi]['fextralist'])
+            int(listarrayfiles['ffilelist'][reallcfi]['fmajor']), 'x').lower()
+        fseeknextfile = listarrayfiles['ffilelist'][reallcfi]['fseeknextfile']
+        if(len(listarrayfiles['ffilelist'][reallcfi]['fextralist']) > listarrayfiles['ffilelist'][reallcfi]['fextrafields'] and len(listarrayfiles['ffilelist'][reallcfi]['fextralist']) > 0):
+            listarrayfiles['ffilelist'][reallcfi]['fextrafields'] = len(
+                listarrayfiles['ffilelist'][reallcfi]['fextralist'])
         if(not followlink and len(extradata) <= 0):
-            extradata = listfoxfiles['ffilelist'][reallcfi]['fextralist']
+            extradata = listarrayfiles['ffilelist'][reallcfi]['fextralist']
         if(not followlink and len(jsondata) <= 0):
-            jsondata = listfoxfiles['ffilelist'][reallcfi]['fjsondata']
-        fcontents = listfoxfiles['ffilelist'][reallcfi]['fcontents']
-        if(not listfoxfiles['ffilelist'][reallcfi]['fcontentasfile']):
+            jsondata = listarrayfiles['ffilelist'][reallcfi]['fjsondata']
+        fcontents = listarrayfiles['ffilelist'][reallcfi]['fcontents']
+        if(not listarrayfiles['ffilelist'][reallcfi]['fcontentasfile']):
             fcontents = MkTempFile(fcontents)
-        typechecktest = CheckCompressionType(fcontents, closefp=False)
+        typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
         fcontents.seek(0, 0)
-        fcencoding = GetFileEncoding(fcontents, False)
+        fcencoding = GetFileEncoding(fcontents, 0, False)
         fcompression = ""
         fcsize = format(int(0), 'x').lower()
         curcompression = "none"
@@ -8333,10 +7894,10 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                 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(listarrayfiles['ffilelist'][reallcfi]['ftype'] == 1 or listarrayfiles['ffilelist'][reallcfi]['ftype'] == 2):
+                getflinkpath = listarrayfiles['ffilelist'][reallcfi]['flinkname']
+                flinkid = prelistarrayfiles['filetoid'][getflinkpath]
+                flinkinfo = listarrayfiles['ffilelist'][flinkid]
                 fheadersize = format(
                     int(flinkinfo['fheadersize']), 'x').lower()
                 fsize = format(int(flinkinfo['fsize']), 'x').lower()
@@ -8373,10 +7934,10 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                 ftypehex = format(flinkinfo['ftype'], 'x').lower()
         else:
             ftypehex = format(
-                listfoxfiles['ffilelist'][reallcfi]['ftype'], 'x').lower()
+                listarrayfiles['ffilelist'][reallcfi]['ftype'], 'x').lower()
         fcurfid = format(curfid, 'x').lower()
         if(not followlink and finode != 0):
-            if(listfoxfiles['ffilelist'][reallcfi]['ftype'] != 1):
+            if(listarrayfiles['ffilelist'][reallcfi]['ftype'] != 1):
                 fcurinode = format(int(curinode), 'x').lower()
                 inodetofile.update({curinode: fname})
                 filetoinode.update({fname: curinode})
@@ -8426,7 +7987,7 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
         outvar = fp.read()
         fp.close()
         return outvar
-    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall(__upload_proto_support__, outfile)):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
@@ -8439,50 +8000,50 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
         return True
 
 
-def RePackFoxFileFromString(instr, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["crc32", "crc32", "crc32"], skipchecksum=False, extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
+def RePackFoxFileFromString(instr, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, filestart=0, seekstart=0, seekend=0, checksumtype=["crc32", "crc32", "crc32"], skipchecksum=False, extradata=[], jsondata={}, formatspecs=__file_format_dict__, seektoend=False, verbose=False, returnfp=False):
     fp = MkTempFile(instr)
-    listfoxfiles = RePackFoxFile(fp, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist,
-                                     checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp)
-    return listfoxfiles
+    listarrayfiles = RePackFoxFile(fp, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, filestart, seekstart, seekend,
+                                     checksumtype, skipchecksum, extradata, jsondata, formatspecs, seektoend, verbose, returnfp)
+    return listarrayfiles
 
 
-def PackFoxFileFromListDir(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, skipchecksum=False, checksumtype=["crc32", "crc32", "crc32"], extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
+def PackFoxFileFromListDir(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, filestart=0, seekstart=0, seekend=0, checksumtype=["crc32", "crc32", "crc32"], skipchecksum=False, extradata=[], jsondata={}, formatspecs=__file_format_dict__, seektoend=False, verbose=False, returnfp=False):
     outarray = MkTempFile()
     packform = PackFoxFile(infiles, outarray, dirlistfromtxt, fmttype, compression, compresswholefile,
                               compressionlevel, compressionuselist, followlink, checksumtype, extradata, formatspecs, verbose, True)
-    listfoxfiles = RePackFoxFile(outarray, outfile, fmttype, compression, compresswholefile,
-                                     compressionlevel, checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp)
-    return listfoxfiles
+    listarrayfiles = RePackFoxFile(outarray, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, filestart, seekstart, seekend,
+                                     checksumtype, skipchecksum, extradata, jsondata, formatspecs, seektoend, verbose, returnfp)
+    return listarrayfiles
 
 
-def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, preservepermissions=True, preservetime=True, seektoend=False, verbose=False, returnfp=False):
+def UnPackFoxFile(infile, outdir=None, followlink=False, filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, preservepermissions=True, preservetime=True, seektoend=False, verbose=False, returnfp=False):
     if(outdir is not None):
         outdir = RemoveWindowsPath(outdir)
     if(verbose):
         logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
     if(isinstance(infile, dict)):
-        listfoxfiles = infile
+        listarrayfiles = infile
     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)
-        listfoxfiles = FoxFileToArray(infile, "auto", seekstart, seekend, False, True, skipchecksum, formatspecs, seektoend, returnfp)
-    if(not listfoxfiles):
+        listarrayfiles = FoxFileToArray(infile, "auto", filestart, seekstart, seekend, False, True, skipchecksum, formatspecs, seektoend, returnfp)
+    if(not listarrayfiles):
         return False
-    lenlist = len(listfoxfiles['ffilelist'])
-    fnumfiles = int(listfoxfiles['fnumfiles'])
+    lenlist = len(listarrayfiles['ffilelist'])
+    fnumfiles = int(listarrayfiles['fnumfiles'])
     lcfi = 0
-    lcfx = int(listfoxfiles['fnumfiles'])
-    if(lenlist > listfoxfiles['fnumfiles'] or lenlist < listfoxfiles['fnumfiles']):
+    lcfx = int(listarrayfiles['fnumfiles'])
+    if(lenlist > listarrayfiles['fnumfiles'] or lenlist < listarrayfiles['fnumfiles']):
         lcfx = int(lenlist)
     else:
-        lcfx = int(listfoxfiles['fnumfiles'])
+        lcfx = int(listarrayfiles['fnumfiles'])
     while(lcfi < lcfx):
         funame = ""
         try:
             import pwd
             try:
                 userinfo = pwd.getpwuid(
-                    listfoxfiles['ffilelist'][lcfi]['fuid'])
+                    listarrayfiles['ffilelist'][lcfi]['fuid'])
                 funame = userinfo.pw_name
             except KeyError:
                 funame = ""
@@ -8493,7 +8054,7 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0,
             import grp
             try:
                 groupinfo = grp.getgrgid(
-                    listfoxfiles['ffilelist'][lcfi]['fgid'])
+                    listarrayfiles['ffilelist'][lcfi]['fgid'])
                 fgname = groupinfo.gr_name
             except KeyError:
                 fgname = ""
@@ -8501,15 +8062,15 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0,
             fgname = ""
         if(verbose):
             VerbosePrintOut(PrependPath(
-                outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
-        if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 0 or listfoxfiles['ffilelist'][lcfi]['ftype'] == 7):
-            with open(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
-                if(not listfoxfiles['ffilelist'][lcfi]['fcontentasfile']):
-                    listfoxfiles['ffilelist'][lcfi]['fcontents'] = MkTempFile(
-                        listfoxfiles['ffilelist'][lcfi]['fcontents'])
-                listfoxfiles['ffilelist'][lcfi]['fcontents'].seek(0, 0)
+                outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 0 or listarrayfiles['ffilelist'][lcfi]['ftype'] == 7):
+            with open(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
+                if(not listarrayfiles['ffilelist'][lcfi]['fcontentasfile']):
+                    listarrayfiles['ffilelist'][lcfi]['fcontents'] = MkTempFile(
+                        listarrayfiles['ffilelist'][lcfi]['fcontents'])
+                listarrayfiles['ffilelist'][lcfi]['fcontents'].seek(0, 0)
                 shutil.copyfileobj(
-                    listfoxfiles['ffilelist'][lcfi]['fcontents'], fpc)
+                    listarrayfiles['ffilelist'][lcfi]['fcontents'], fpc)
                 try:
                     fpc.flush()
                     if(hasattr(os, "sync")):
@@ -8520,20 +8081,20 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0,
                     pass
                 except OSError:
                     pass
-            if(hasattr(os, "chown") and funame == listfoxfiles['ffilelist'][lcfi]['funame'] and fgname == listfoxfiles['ffilelist'][lcfi]['fgname'] and preservepermissions):
-                os.chown(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']),
-                         listfoxfiles['ffilelist'][lcfi]['fuid'], listfoxfiles['ffilelist'][lcfi]['fgid'])
+            if(hasattr(os, "chown") and funame == listarrayfiles['ffilelist'][lcfi]['funame'] and fgname == listarrayfiles['ffilelist'][lcfi]['fgname'] and preservepermissions):
+                os.chown(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']),
+                         listarrayfiles['ffilelist'][lcfi]['fuid'], listarrayfiles['ffilelist'][lcfi]['fgid'])
             if(preservepermissions):
                 os.chmod(PrependPath(
-                    outdir, listfoxfiles['ffilelist'][lcfi]['fname']), listfoxfiles['ffilelist'][lcfi]['fchmode'])
+                    outdir, listarrayfiles['ffilelist'][lcfi]['fname']), listarrayfiles['ffilelist'][lcfi]['fchmode'])
             if(preservetime):
-                os.utime(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), (
-                    listfoxfiles['ffilelist'][lcfi]['fatime'], listfoxfiles['ffilelist'][lcfi]['fmtime']))
-        if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 1):
+                os.utime(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']), (
+                    listarrayfiles['ffilelist'][lcfi]['fatime'], listarrayfiles['ffilelist'][lcfi]['fmtime']))
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 1):
             if(followlink):
-                getflinkpath = listfoxfiles['ffilelist'][lcfi]['flinkname']
-                flinkid = prelistfoxfiles['filetoid'][getflinkpath]
-                flinkinfo = listfoxfiles['ffilelist'][flinkid]
+                getflinkpath = listarrayfiles['ffilelist'][lcfi]['flinkname']
+                flinkid = prelistarrayfiles['filetoid'][getflinkpath]
+                flinkinfo = listarrayfiles['ffilelist'][flinkid]
                 funame = ""
                 try:
                     import pwd
@@ -8555,7 +8116,7 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0,
                 except ImportError:
                     fgname = ""
                 if(flinkinfo['ftype'] == 0 or flinkinfo['ftype'] == 7):
-                    with open(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
+                    with open(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
                         if(not flinkinfo['fcontentasfile']):
                             flinkinfo['fcontents'] = MkTempFile(
                                 flinkinfo['fcontents'])
@@ -8573,46 +8134,46 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0,
                             pass
                     if(hasattr(os, "chown") and funame == flinkinfo['funame'] and fgname == flinkinfo['fgname'] and preservepermissions):
                         os.chown(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
                     if(preservepermissions):
                         os.chmod(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
                     if(preservetime):
-                        os.utime(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), (
+                        os.utime(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']), (
                             flinkinfo['fatime'], flinkinfo['fmtime']))
                 if(flinkinfo['ftype'] == 1):
                     os.link(flinkinfo['flinkname'], PrependPath(
-                        outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
+                        outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
                 if(flinkinfo['ftype'] == 2):
                     os.symlink(flinkinfo['flinkname'], PrependPath(
-                        outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
+                        outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
                 if(flinkinfo['ftype'] == 5):
                     if(preservepermissions):
                         os.mkdir(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
                     else:
                         os.mkdir(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
                     if(hasattr(os, "chown") and funame == flinkinfo['funame'] and fgname == flinkinfo['fgname'] and preservepermissions):
                         os.chown(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
                     if(preservepermissions):
                         os.chmod(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
                     if(preservetime):
-                        os.utime(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), (
+                        os.utime(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']), (
                             flinkinfo['fatime'], flinkinfo['fmtime']))
                 if(flinkinfo['ftype'] == 6 and hasattr(os, "mkfifo")):
                     os.mkfifo(PrependPath(
-                        outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
+                        outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
             else:
-                os.link(listfoxfiles['ffilelist'][lcfi]['flinkname'], PrependPath(
-                    outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
-        if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 2):
+                os.link(listarrayfiles['ffilelist'][lcfi]['flinkname'], PrependPath(
+                    outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 2):
             if(followlink):
-                getflinkpath = listfoxfiles['ffilelist'][lcfi]['flinkname']
-                flinkid = prelistfoxfiles['filetoid'][getflinkpath]
-                flinkinfo = listfoxfiles['ffilelist'][flinkid]
+                getflinkpath = listarrayfiles['ffilelist'][lcfi]['flinkname']
+                flinkid = prelistarrayfiles['filetoid'][getflinkpath]
+                flinkinfo = listarrayfiles['ffilelist'][flinkid]
                 funame = ""
                 try:
                     import pwd
@@ -8634,7 +8195,7 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0,
                 except ImportError:
                     fgname = ""
                 if(flinkinfo['ftype'] == 0 or flinkinfo['ftype'] == 7):
-                    with open(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
+                    with open(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
                         if(not flinkinfo['fcontentasfile']):
                             flinkinfo['fcontents'] = MkTempFile(
                                 flinkinfo['fcontents'])
@@ -8652,71 +8213,71 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0,
                             pass
                     if(hasattr(os, "chown") and funame == flinkinfo['funame'] and fgname == flinkinfo['fgname'] and preservepermissions):
                         os.chown(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
                     if(preservepermissions):
                         os.chmod(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
                     if(preservetime):
-                        os.utime(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), (
+                        os.utime(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']), (
                             flinkinfo['fatime'], flinkinfo['fmtime']))
                 if(flinkinfo['ftype'] == 1):
                     os.link(flinkinfo['flinkname'], PrependPath(
-                        outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
+                        outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
                 if(flinkinfo['ftype'] == 2):
                     os.symlink(flinkinfo['flinkname'], PrependPath(
-                        outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
+                        outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
                 if(flinkinfo['ftype'] == 5):
                     if(preservepermissions):
                         os.mkdir(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
                     else:
                         os.mkdir(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
                     if(hasattr(os, "chown") and funame == flinkinfo['funame'] and fgname == flinkinfo['fgname'] and preservepermissions):
                         os.chown(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
                     if(preservepermissions):
                         os.chmod(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
                     if(preservetime):
-                        os.utime(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), (
+                        os.utime(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']), (
                             flinkinfo['fatime'], flinkinfo['fmtime']))
                 if(flinkinfo['ftype'] == 6 and hasattr(os, "mkfifo")):
                     os.mkfifo(PrependPath(
-                        outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
+                        outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
             else:
-                os.symlink(listfoxfiles['ffilelist'][lcfi]['flinkname'], PrependPath(
-                    outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
-        if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 5):
+                os.symlink(listarrayfiles['ffilelist'][lcfi]['flinkname'], PrependPath(
+                    outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 5):
             if(preservepermissions):
                 os.mkdir(PrependPath(
-                    outdir, listfoxfiles['ffilelist'][lcfi]['fname']), listfoxfiles['ffilelist'][lcfi]['fchmode'])
+                    outdir, listarrayfiles['ffilelist'][lcfi]['fname']), listarrayfiles['ffilelist'][lcfi]['fchmode'])
             else:
                 os.mkdir(PrependPath(
-                    outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
-            if(hasattr(os, "chown") and funame == listfoxfiles['ffilelist'][lcfi]['funame'] and fgname == listfoxfiles['ffilelist'][lcfi]['fgname'] and preservepermissions):
-                os.chown(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']),
-                         listfoxfiles['ffilelist'][lcfi]['fuid'], listfoxfiles['ffilelist'][lcfi]['fgid'])
+                    outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
+            if(hasattr(os, "chown") and funame == listarrayfiles['ffilelist'][lcfi]['funame'] and fgname == listarrayfiles['ffilelist'][lcfi]['fgname'] and preservepermissions):
+                os.chown(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']),
+                         listarrayfiles['ffilelist'][lcfi]['fuid'], listarrayfiles['ffilelist'][lcfi]['fgid'])
             if(preservepermissions):
                 os.chmod(PrependPath(
-                    outdir, listfoxfiles['ffilelist'][lcfi]['fname']), listfoxfiles['ffilelist'][lcfi]['fchmode'])
+                    outdir, listarrayfiles['ffilelist'][lcfi]['fname']), listarrayfiles['ffilelist'][lcfi]['fchmode'])
             if(preservetime):
-                os.utime(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), (
-                    listfoxfiles['ffilelist'][lcfi]['fatime'], listfoxfiles['ffilelist'][lcfi]['fmtime']))
-        if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 6 and hasattr(os, "mkfifo")):
+                os.utime(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']), (
+                    listarrayfiles['ffilelist'][lcfi]['fatime'], listarrayfiles['ffilelist'][lcfi]['fmtime']))
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 6 and hasattr(os, "mkfifo")):
             os.mkfifo(PrependPath(
-                outdir, listfoxfiles['ffilelist'][lcfi]['fname']), listfoxfiles['ffilelist'][lcfi]['fchmode'])
+                outdir, listarrayfiles['ffilelist'][lcfi]['fname']), listarrayfiles['ffilelist'][lcfi]['fchmode'])
         lcfi = lcfi + 1
     if(returnfp):
-        return listfoxfiles['ffilelist']['fp']
+        return listarrayfiles['ffilelist']['fp']
     else:
         return True
 
 
 def UnPackFoxFileString(instr, outdir=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
     fp = MkTempFile(instr)
-    listfoxfiles = UnPackFoxFile(fp, outdir, followlink, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, returnfp)
-    return listfoxfiles
+    listarrayfiles = UnPackFoxFile(fp, outdir, followlink, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, returnfp)
+    return listarrayfiles
 
 def ftype_to_str(ftype):
     mapping = {
@@ -8733,64 +8294,64 @@ def ftype_to_str(ftype):
     # Default to "file" if unknown
     return mapping.get(ftype, "file")
 
-def FoxFileListFiles(infile, fmttype="auto", seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, newstyle=False, returnfp=False):
+def FoxFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, newstyle=False, returnfp=False):
     if(verbose):
         logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
     if(isinstance(infile, dict)):
-        listfoxfiles = infile
+        listarrayfiles = infile
     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)
-        listfoxfiles = FoxFileToArray(infile, fmttype, seekstart, seekend, True, False, False, skipchecksum, formatspecs, seektoend, returnfp)
-    if(not listfoxfiles):
+        listarrayfiles = FoxFileToArray(infile, fmttype, filestart, seekstart, seekend, True, False, False, skipchecksum, formatspecs, seektoend, returnfp)
+    if(not listarrayfiles):
         return False
-    lenlist = len(listfoxfiles['ffilelist'])
-    fnumfiles = int(listfoxfiles['fnumfiles'])
+    lenlist = len(listarrayfiles['ffilelist'])
+    fnumfiles = int(listarrayfiles['fnumfiles'])
     lcfi = 0
-    lcfx = int(listfoxfiles['fnumfiles'])
-    if(lenlist > listfoxfiles['fnumfiles'] or lenlist < listfoxfiles['fnumfiles']):
+    lcfx = int(listarrayfiles['fnumfiles'])
+    if(lenlist > listarrayfiles['fnumfiles'] or lenlist < listarrayfiles['fnumfiles']):
         lcfx = int(lenlist)
     else:
-        lcfx = int(listfoxfiles['fnumfiles'])
+        lcfx = int(listarrayfiles['fnumfiles'])
     returnval = {}
     while(lcfi < lcfx):
-        returnval.update({lcfi: listfoxfiles['ffilelist'][lcfi]['fname']})
+        returnval.update({lcfi: listarrayfiles['ffilelist'][lcfi]['fname']})
         if(not verbose):
-            VerbosePrintOut(listfoxfiles['ffilelist'][lcfi]['fname'])
+            VerbosePrintOut(listarrayfiles['ffilelist'][lcfi]['fname'])
         if(verbose):
             permissions = {'access': {'0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': (
                 'r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx')}, 'roles': {0: 'owner', 1: 'group', 2: 'other'}}
-            printfname = listfoxfiles['ffilelist'][lcfi]['fname']
-            if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 1):
-                printfname = listfoxfiles['ffilelist'][lcfi]['fname'] + \
-                    " link to " + listfoxfiles['ffilelist'][lcfi]['flinkname']
-            if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 2):
-                printfname = listfoxfiles['ffilelist'][lcfi]['fname'] + \
-                    " -> " + listfoxfiles['ffilelist'][lcfi]['flinkname']
-            fuprint = listfoxfiles['ffilelist'][lcfi]['funame']
+            printfname = listarrayfiles['ffilelist'][lcfi]['fname']
+            if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 1):
+                printfname = listarrayfiles['ffilelist'][lcfi]['fname'] + \
+                    " link to " + listarrayfiles['ffilelist'][lcfi]['flinkname']
+            if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 2):
+                printfname = listarrayfiles['ffilelist'][lcfi]['fname'] + \
+                    " -> " + listarrayfiles['ffilelist'][lcfi]['flinkname']
+            fuprint = listarrayfiles['ffilelist'][lcfi]['funame']
             if(len(fuprint) <= 0):
-                fuprint = listfoxfiles['ffilelist'][lcfi]['fuid']
-            fgprint = listfoxfiles['ffilelist'][lcfi]['fgname']
+                fuprint = listarrayfiles['ffilelist'][lcfi]['fuid']
+            fgprint = listarrayfiles['ffilelist'][lcfi]['fgname']
             if(len(fgprint) <= 0):
-                fgprint = listfoxfiles['ffilelist'][lcfi]['fgid']
+                fgprint = listarrayfiles['ffilelist'][lcfi]['fgid']
             if(newstyle):
-                VerbosePrintOut(ftype_to_str(listfoxfiles['ffilelist'][lcfi]['ftype']) + "\t" + listfoxfiles['ffilelist'][lcfi]['fcompression'] + "\t" + str(
-                listfoxfiles['ffilelist'][lcfi]['fsize']).rjust(15) + "\t" + printfname)
+                VerbosePrintOut(ftype_to_str(listarrayfiles['ffilelist'][lcfi]['ftype']) + "\t" + listarrayfiles['ffilelist'][lcfi]['fcompression'] + "\t" + str(
+                listarrayfiles['ffilelist'][lcfi]['fsize']).rjust(15) + "\t" + printfname)
             else:
-                VerbosePrintOut(PrintPermissionString(listfoxfiles['ffilelist'][lcfi]['fmode'], listfoxfiles['ffilelist'][lcfi]['ftype']) + " " + str(fuprint) + "/" + str(fgprint) + " " + str(
-                listfoxfiles['ffilelist'][lcfi]['fsize']).rjust(15) + " " + datetime.datetime.utcfromtimestamp(listfoxfiles['ffilelist'][lcfi]['fmtime']).strftime('%Y-%m-%d %H:%M') + " " + printfname)
+                VerbosePrintOut(PrintPermissionString(listarrayfiles['ffilelist'][lcfi]['fmode'], listarrayfiles['ffilelist'][lcfi]['ftype']) + " " + str(fuprint) + "/" + str(fgprint) + " " + str(
+                listarrayfiles['ffilelist'][lcfi]['fsize']).rjust(15) + " " + datetime.datetime.utcfromtimestamp(listarrayfiles['ffilelist'][lcfi]['fmtime']).strftime('%Y-%m-%d %H:%M') + " " + printfname)
         lcfi = lcfi + 1
     if(returnfp):
-        return listfoxfiles['fp']
+        return listarrayfiles['fp']
     else:
         return True
 
 
 def FoxFileStringListFiles(instr, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, newstyle=False, returnfp=False):
     fp = MkTempFile(instr)
-    listfoxfiles = FoxFileListFiles(
+    listarrayfiles = FoxFileListFiles(
         instr, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, newstyle, returnfp)
-    return listfoxfiles
+    return listarrayfiles
 
 
 def TarFileListFiles(infile, verbose=False, returnfp=False):
@@ -8806,7 +8367,7 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
         if(not infile):
             return False
         infile.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
+    elif(re.findall(__download_proto_support__, infile)):
         infile = download_file_from_internet_file(infile)
         infile.seek(0, 0)
         if(not infile):
@@ -8830,7 +8391,7 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
                 return False
     try:
         if(hasattr(infile, "read") or hasattr(infile, "write")):
-            compresscheck = CheckCompressionType(infile, formatspecs, False)
+            compresscheck = CheckCompressionType(infile, formatspecs, 0, False)
             if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
                 formatspecs = formatspecs[compresscheck]
             if(compresscheck=="zstd"):
@@ -8842,7 +8403,7 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
             else:
                 tarfp = tarfile.open(fileobj=infile, mode="r")
         else:
-            compresscheck = CheckCompressionType(infile, formatspecs, True)
+            compresscheck = CheckCompressionType(infile, formatspecs, 0, True)
             if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
                 formatspecs = formatspecs[compresscheck]
             if(compresscheck=="zstd"):
@@ -8913,7 +8474,7 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
                 member.size).rjust(15) + " " + datetime.datetime.utcfromtimestamp(member.mtime).strftime('%Y-%m-%d %H:%M') + " " + printfname)
         lcfi = lcfi + 1
     if(returnfp):
-        return listfoxfiles['fp']
+        return listarrayfiles['fp']
     else:
         return True
 
@@ -8931,7 +8492,7 @@ def ZipFileListFiles(infile, verbose=False, returnfp=False):
         if(not infile):
             return False
         infile.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
+    elif(re.findall(__download_proto_support__, infile)):
         infile = download_file_from_internet_file(infile)
         infile.seek(0, 0)
         if(not infile):
@@ -9046,7 +8607,7 @@ def ZipFileListFiles(infile, verbose=False, returnfp=False):
                 15) + " " + datetime.datetime.utcfromtimestamp(int(time.mktime(member.date_time + (0, 0, -1)))).strftime('%Y-%m-%d %H:%M') + " " + printfname)
         lcfi = lcfi + 1
     if(returnfp):
-        return listfoxfiles['fp']
+        return listarrayfiles['fp']
     else:
         return True
 
@@ -9184,7 +8745,7 @@ if(rarfile_support):
                     member.file_size).rjust(15) + " " + member.mtime.strftime('%Y-%m-%d %H:%M') + " " + printfname)
             lcfi = lcfi + 1
         if(returnfp):
-            return listfoxfiles['fp']
+            return listarrayfiles['fp']
         else:
             return True
 
@@ -9202,7 +8763,7 @@ if(py7zr_support):
         returnval = {}
         szpfp = py7zr.SevenZipFile(infile, mode="r")
         file_content = szpfp.readall()
-        #sztest = szpfp.testzip();
+        #sztest = szpfp.testzip()
         sztestalt = szpfp.test()
         if(sztestalt):
             VerbosePrintOut("Bad file found!")
@@ -9291,7 +8852,7 @@ if(py7zr_support):
                     fsize).rjust(15) + " " + member.creationtime.strftime('%Y-%m-%d %H:%M') + " " + printfname)
             lcfi = lcfi + 1
         if(returnfp):
-            return listfoxfiles['fp']
+            return listarrayfiles['fp']
         else:
             return True
 
@@ -9299,7 +8860,7 @@ if(py7zr_support):
 def InFileListFiles(infile, verbose=False, formatspecs=__file_format_multi_dict__, seektoend=False, newstyle=False, returnfp=False):
     if(verbose):
         logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
-    checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+    checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
     if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
@@ -9321,9 +8882,9 @@ def ListDirListFiles(infiles, dirlistfromtxt=False, compression="auto", compress
     outarray = MkTempFile()
     packform = PackFoxFile(infiles, outarray, dirlistfromtxt, compression, compresswholefile,
                               compressionlevel, followlink, checksumtype, formatspecs, False, True)
-    listfoxfiles = FoxFileListFiles(
+    listarrayfiles = FoxFileListFiles(
         outarray, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, returnfp)
-    return listfoxfiles
+    return listarrayfiles
 
 """
 PyNeoFile compatibility layer
@@ -9342,31 +8903,44 @@ def make_empty_archive_file_neo(outfile=None, fmttype=None, checksumtype='crc32'
     return make_empty_file_neo(outfile, fmttype, checksumtype, formatspecs, encoding, returnfp)
 
 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 PackArchiveFile(infiles, outfile, False, "auto", compression, False, compression_level, compressionlistalt, False, checksumtypes, [], {}, formatspecs, False, returnfp)
+    return PackFoxFile(infiles, outfile, False, "auto", compression, False, compression_level, compressionlistalt, False, checksumtypes, [], {}, formatspecs, False, returnfp)
 
 def archive_to_array_neo(infile, formatspecs=__file_format_multi_dict__, listonly=False, skipchecksum=False, uncompress=True, returnfp=False):
-    return ArchiveFileToArray(infile, "auto", 0, 0, listonly, True, uncompress, skipchecksum, formatspecs, False, returnfp)
+    return FoxFileToArray(infile, "auto", 0, 0, 0, listonly, True, uncompress, skipchecksum, formatspecs, False, returnfp)
 
 def unpack_neo(infile, outdir='.', formatspecs=__file_format_multi_dict__, skipchecksum=False, uncompress=True, returnfp=False):
-    return UnPackArchiveFile(infile, outdir, False, 0, 0, skipchecksum, formatspecs, True, True, False, False, returnfp)
+    return UnPackFoxFile(infile, outdir, False, 0, 0, skipchecksum, formatspecs, True, True, False, False, returnfp)
 
 def repack_neo(infile, outfile=None, formatspecs=__file_format_dict__, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
-    return RePackArchiveFile(infile, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
+    return RePackFoxFile(infile, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
 
 def archivefilevalidate_neo(infile, formatspecs=__file_format_multi_dict__, verbose=False, return_details=False, returnfp=False):
-    return ArchiveFileValidate(infile, "auto", formatspecs, False, verbose, returnfp)
+    return FoxFileValidate(infile, "auto", formatspecs, False, verbose, returnfp)
 
 def archivefilelistfiles_neo(infile, formatspecs=__file_format_multi_dict__, advanced=False, include_dirs=True, returnfp=False):
-    return ArchiveFileListFiles(infile, "auto", 0, 0, False, formatspecs, False, True, advanced, returnfp)
+    return FoxFileListFiles(infile, "auto", 0, 0, False, formatspecs, False, True, advanced, returnfp)
 
 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 RePackArchiveFile(intmp, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
+    intmp = InFileToArray(infile, 0, 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)
+
+def detect_cwd(ftp, file_dir):
+    """
+    Test whether cwd into file_dir works. Returns True if it does,
+    False if not (so absolute paths should be used).
+    """
+    if not file_dir or file_dir in ("/", ""):
+        return False  # nothing to cwd into
+    try:
+        ftp.cwd(file_dir)
+        return True
+    except all_errors:
+        return False
 
 def download_file_from_ftp_file(url):
     urlparts = urlparse(url)
-    file_name = os.path.basename(urlparts.path)
-    file_dir = os.path.dirname(urlparts.path)
+    file_name = os.path.basename(unquote(urlparts.path))
+    file_dir = os.path.dirname(unquote(urlparts.path))
     if(urlparts.username is not None):
         ftp_username = urlparts.username
     else:
@@ -9383,7 +8957,7 @@ def download_file_from_ftp_file(url):
         ftp = FTP_TLS()
     else:
         return False
-    if(urlparts.scheme == "sftp"):
+    if(urlparts.scheme == "sftp" or urlparts.scheme == "scp"):
         if(__use_pysftp__):
             return download_file_from_pysftp_file(url)
         else:
@@ -9401,26 +8975,70 @@ def download_file_from_ftp_file(url):
     except socket.timeout:
         log.info("Error With URL "+url)
         return False
-    ftp.login(urlparts.username, urlparts.password)
-    if(urlparts.scheme == "ftps"):
-        ftp.prot_p()
+    if(urlparts.scheme == "ftps" or isinstance(ftp, FTP_TLS)):
+        try:
+            ftp.auth()
+        except all_errors:
+            pass
+    ftp.login(ftp_username, ftp_password)
+    if(urlparts.scheme == "ftps" or isinstance(ftp, FTP_TLS)):
+        try:
+            ftp.prot_p()
+        except all_errors:
+            ftp.prot_c()
+    # UTF-8 filenames if supported
+    try:
+        ftp.sendcmd("OPTS UTF8 ON")
+        ftp.encoding = "utf-8"
+    except all_errors:
+        pass
+    is_cwd_allowed = detect_cwd(ftp, file_dir)
     ftpfile = MkTempFile()
-    ftp.retrbinary("RETR "+urlparts.path, ftpfile.write)
-    #ftp.storbinary("STOR "+urlparts.path, ftpfile.write);
+    # Try EPSV first, then fall back
+    try:
+        ftp.force_epsv = True
+        ftp.sendcmd("EPSV")   # request extended passive
+        if(is_cwd_allowed):
+            ftp.retrbinary("RETR "+file_name, ftpfile.write)
+        else:
+            ftp.retrbinary("RETR "+unquote(urlparts.path), ftpfile.write)
+    except all_errors:
+        try:
+            ftp.set_pasv(True)
+            if(is_cwd_allowed):
+                ftp.retrbinary("RETR "+file_name, ftpfile.write)
+            else:
+                ftp.retrbinary("RETR "+unquote(urlparts.path), ftpfile.write)
+        except all_errors:
+            ftp.set_pasv(False)
+            if(is_cwd_allowed):
+                ftp.retrbinary("RETR "+file_name, ftpfile.write)
+            else:
+                ftp.retrbinary("RETR "+unquote(urlparts.path), ftpfile.write)
     ftp.close()
     ftpfile.seek(0, 0)
     return ftpfile
 
 
+def download_file_from_ftps_file(url):
+    return download_file_from_ftp_file(url)
+
+
 def download_file_from_ftp_string(url):
     ftpfile = download_file_from_ftp_file(url)
-    return ftpfile.read()
+    ftpout = ftpfile.read()
+    ftpfile.close()
+    return ftpout
+
+
+def download_file_from_ftps_string(url):
+    return download_file_from_ftp_string(url)
 
 
 def upload_file_to_ftp_file(ftpfile, url):
     urlparts = urlparse(url)
-    file_name = os.path.basename(urlparts.path)
-    file_dir = os.path.dirname(urlparts.path)
+    file_name = os.path.basename(unquote(urlparts.path))
+    file_dir = os.path.dirname(unquote(urlparts.path))
     if(urlparts.username is not None):
         ftp_username = urlparts.username
     else:
@@ -9437,7 +9055,7 @@ def upload_file_to_ftp_file(ftpfile, url):
         ftp = FTP_TLS()
     else:
         return False
-    if(urlparts.scheme == "sftp"):
+    if(urlparts.scheme == "sftp" or urlparts.scheme == "scp"):
         if(__use_pysftp__):
             return upload_file_to_pysftp_file(url)
         else:
@@ -9455,15 +9073,55 @@ def upload_file_to_ftp_file(ftpfile, url):
     except socket.timeout:
         log.info("Error With URL "+url)
         return False
-    ftp.login(urlparts.username, urlparts.password)
-    if(urlparts.scheme == "ftps"):
-        ftp.prot_p()
-    ftp.storbinary("STOR "+urlparts.path, ftpfile)
+    if(urlparts.scheme == "ftps" or isinstance(ftp, FTP_TLS)):
+        try:
+            ftp.auth()
+        except all_errors:
+            pass
+    ftp.login(ftp_username, ftp_password)
+    if(urlparts.scheme == "ftps" or isinstance(ftp, FTP_TLS)):
+        try:
+            ftp.prot_p()
+        except all_errors:
+            ftp.prot_c()
+    # UTF-8 filenames if supported
+    try:
+        ftp.sendcmd("OPTS UTF8 ON")
+        ftp.encoding = "utf-8"
+    except all_errors:
+        pass
+    is_cwd_allowed = detect_cwd(ftp, file_dir)
+    ftpfile.seek(0, 0)
+    # Try EPSV first, then fall back
+    try:
+        ftp.force_epsv = True
+        ftp.sendcmd("EPSV")   # request extended passive
+        if(is_cwd_allowed):
+            ftp.storbinary("STOR "+file_name, ftpfile)
+        else:
+            ftp.storbinary("STOR "+unquote(urlparts.path), ftpfile)
+    except all_errors:
+        try:
+            ftp.set_pasv(True)
+            if(is_cwd_allowed):
+                ftp.storbinary("STOR "+file_name, ftpfile)
+            else:
+                ftp.storbinary("STOR "+unquote(urlparts.path), ftpfile)
+        except all_errors:
+            ftp.set_pasv(False)
+            if(is_cwd_allowed):
+                ftp.storbinary("STOR "+file_name, ftpfile)
+            else:
+                ftp.storbinary("STOR "+unquote(urlparts.path), ftpfile)
     ftp.close()
     ftpfile.seek(0, 0)
     return ftpfile
 
 
+def upload_file_to_ftps_file(ftpfile, url):
+    return upload_file_to_ftp_file(ftpfile, url)
+
+
 def upload_file_to_ftp_string(ftpstring, url):
     ftpfileo = MkTempFile(ftpstring)
     ftpfile = upload_file_to_ftp_file(ftpfileo, url)
@@ -9471,6 +9129,10 @@ def upload_file_to_ftp_string(ftpstring, url):
     return ftpfile
 
 
+def upload_file_to_ftps_string(ftpstring, url):
+    return upload_file_to_ftp_string(ftpstring, url)
+
+
 class RawIteratorWrapper:
     def __init__(self, iterator):
         self.iterator = iterator
@@ -9508,7 +9170,7 @@ def download_file_from_http_file(url, headers=None, usehttp=__use_http_lib__):
                               urlparts.params, urlparts.query, urlparts.fragment))
 
     # Handle SFTP/FTP
-    if urlparts.scheme == "sftp":
+    if urlparts.scheme == "sftp" or urlparts.scheme == "scp":
         if __use_pysftp__:
             return download_file_from_pysftp_file(url)
         else:
@@ -9581,14 +9243,16 @@ def download_file_from_http_file(url, headers=None, usehttp=__use_http_lib__):
 
 def download_file_from_http_string(url, headers=geturls_headers_pyfile_python_alt, usehttp=__use_http_lib__):
     httpfile = download_file_from_http_file(url, headers, usehttp)
-    return httpfile.read()
+    httpout = httpfile.read()
+    httpfile.close()
+    return httpout
 
 
 if(haveparamiko):
     def download_file_from_sftp_file(url):
         urlparts = urlparse(url)
-        file_name = os.path.basename(urlparts.path)
-        file_dir = os.path.dirname(urlparts.path)
+        file_name = os.path.basename(unquote(urlparts.path))
+        file_dir = os.path.dirname(unquote(urlparts.path))
         sftp_port = urlparts.port
         if(urlparts.port is None):
             sftp_port = 22
@@ -9608,14 +9272,14 @@ if(haveparamiko):
             return download_file_from_ftp_file(url)
         elif(urlparts.scheme == "http" or urlparts.scheme == "https"):
             return download_file_from_http_file(url)
-        if(urlparts.scheme != "sftp"):
+        if(urlparts.scheme != "sftp" and urlparts.scheme != "scp"):
             return False
         ssh = paramiko.SSHClient()
         ssh.load_system_host_keys()
         ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
         try:
             ssh.connect(urlparts.hostname, port=sftp_port,
-                        username=urlparts.username, password=urlparts.password)
+                        username=sftp_username, password=urlparts.password)
         except paramiko.ssh_exception.SSHException:
             return False
         except socket.gaierror:
@@ -9626,7 +9290,7 @@ if(haveparamiko):
             return False
         sftp = ssh.open_sftp()
         sftpfile = MkTempFile()
-        sftp.getfo(urlparts.path, sftpfile)
+        sftp.getfo(unquote(urlparts.path), sftpfile)
         sftp.close()
         ssh.close()
         sftpfile.seek(0, 0)
@@ -9638,7 +9302,9 @@ else:
 if(haveparamiko):
     def download_file_from_sftp_string(url):
         sftpfile = download_file_from_sftp_file(url)
-        return sftpfile.read()
+        sftpout = sftpfile.read()
+        sftpfile.close()
+        return sftpout
 else:
     def download_file_from_sftp_string(url):
         return False
@@ -9646,8 +9312,8 @@ else:
 if(haveparamiko):
     def upload_file_to_sftp_file(sftpfile, url):
         urlparts = urlparse(url)
-        file_name = os.path.basename(urlparts.path)
-        file_dir = os.path.dirname(urlparts.path)
+        file_name = os.path.basename(unquote(urlparts.path))
+        file_dir = os.path.dirname(unquote(urlparts.path))
         sftp_port = urlparts.port
         if(urlparts.port is None):
             sftp_port = 22
@@ -9664,17 +9330,17 @@ if(haveparamiko):
         else:
             sftp_password = ""
         if(urlparts.scheme == "ftp"):
-            return upload_file_to_ftp_file(url)
+            return upload_file_to_ftp_file(sftpfile, url)
         elif(urlparts.scheme == "http" or urlparts.scheme == "https"):
             return False
-        if(urlparts.scheme != "sftp"):
+        if(urlparts.scheme != "sftp" and urlparts.scheme != "scp"):
             return False
         ssh = paramiko.SSHClient()
         ssh.load_system_host_keys()
         ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
         try:
             ssh.connect(urlparts.hostname, port=sftp_port,
-                        username=urlparts.username, password=urlparts.password)
+                        username=sftp_username, password=sftp_password)
         except paramiko.ssh_exception.SSHException:
             return False
         except socket.gaierror:
@@ -9684,7 +9350,8 @@ if(haveparamiko):
             log.info("Error With URL "+url)
             return False
         sftp = ssh.open_sftp()
-        sftp.putfo(sftpfile, urlparts.path)
+        sftpfile.seek(0, 0)
+        sftp.putfo(sftpfile, unquote(urlparts.path))
         sftp.close()
         ssh.close()
         sftpfile.seek(0, 0)
@@ -9706,8 +9373,8 @@ else:
 if(havepysftp):
     def download_file_from_pysftp_file(url):
         urlparts = urlparse(url)
-        file_name = os.path.basename(urlparts.path)
-        file_dir = os.path.dirname(urlparts.path)
+        file_name = os.path.basename(unquote(urlparts.path))
+        file_dir = os.path.dirname(unquote(urlparts.path))
         sftp_port = urlparts.port
         if(urlparts.port is None):
             sftp_port = 22
@@ -9727,11 +9394,11 @@ if(havepysftp):
             return download_file_from_ftp_file(url)
         elif(urlparts.scheme == "http" or urlparts.scheme == "https"):
             return download_file_from_http_file(url)
-        if(urlparts.scheme != "sftp"):
+        if(urlparts.scheme != "sftp" and urlparts.scheme != "scp"):
             return False
         try:
-            pysftp.Connection(urlparts.hostname, port=sftp_port,
-                              username=urlparts.username, password=urlparts.password)
+            sftp = pysftp.Connection(urlparts.hostname, port=sftp_port,
+                              username=sftp_username, password=sftp_password)
         except paramiko.ssh_exception.SSHException:
             return False
         except socket.gaierror:
@@ -9740,9 +9407,8 @@ if(havepysftp):
         except socket.timeout:
             log.info("Error With URL "+url)
             return False
-        sftp = ssh.open_sftp()
         sftpfile = MkTempFile()
-        sftp.getfo(urlparts.path, sftpfile)
+        sftp.getfo(unquote(urlparts.path), sftpfile)
         sftp.close()
         ssh.close()
         sftpfile.seek(0, 0)
@@ -9754,7 +9420,9 @@ else:
 if(havepysftp):
     def download_file_from_pysftp_string(url):
         sftpfile = download_file_from_pysftp_file(url)
-        return sftpfile.read()
+        sftpout = sftpfile.read()
+        sftpfile.close()
+        return sftpout
 else:
     def download_file_from_pysftp_string(url):
         return False
@@ -9762,8 +9430,8 @@ else:
 if(havepysftp):
     def upload_file_to_pysftp_file(sftpfile, url):
         urlparts = urlparse(url)
-        file_name = os.path.basename(urlparts.path)
-        file_dir = os.path.dirname(urlparts.path)
+        file_name = os.path.basename(unquote(urlparts.path))
+        file_dir = os.path.dirname(unquote(urlparts.path))
         sftp_port = urlparts.port
         if(urlparts.port is None):
             sftp_port = 22
@@ -9780,14 +9448,14 @@ if(havepysftp):
         else:
             sftp_password = ""
         if(urlparts.scheme == "ftp"):
-            return upload_file_to_ftp_file(url)
+            return upload_file_to_ftp_file(sftpfile, url)
         elif(urlparts.scheme == "http" or urlparts.scheme == "https"):
             return False
-        if(urlparts.scheme != "sftp"):
+        if(urlparts.scheme != "sftp" and urlparts.scheme != "scp"):
             return False
         try:
-            pysftp.Connection(urlparts.hostname, port=sftp_port,
-                              username=urlparts.username, password=urlparts.password)
+            sftp = pysftp.Connection(urlparts.hostname, port=sftp_port,
+                              username=sftp_username, password=sftp_password)
         except paramiko.ssh_exception.SSHException:
             return False
         except socket.gaierror:
@@ -9796,8 +9464,8 @@ if(havepysftp):
         except socket.timeout:
             log.info("Error With URL "+url)
             return False
-        sftp = ssh.open_sftp()
-        sftp.putfo(sftpfile, urlparts.path)
+        sftpfile.seek(0, 0)
+        sftp.putfo(sftpfile, unquote(urlparts.path))
         sftp.close()
         ssh.close()
         sftpfile.seek(0, 0)
@@ -9823,7 +9491,7 @@ def download_file_from_internet_file(url, headers=geturls_headers_pyfile_python_
         return download_file_from_http_file(url, headers, usehttp)
     elif(urlparts.scheme == "ftp" or urlparts.scheme == "ftps"):
         return download_file_from_ftp_file(url)
-    elif(urlparts.scheme == "sftp"):
+    elif(urlparts.scheme == "sftp" or urlparts.scheme == "scp"):
         if(__use_pysftp__ and havepysftp):
             return download_file_from_pysftp_file(url)
         else:
@@ -9833,9 +9501,9 @@ def download_file_from_internet_file(url, headers=geturls_headers_pyfile_python_
     return False
 
 
-def download_file_from_internet_uncompress_file(url, headers=geturls_headers_pyfile_python_alt, formatspecs=__file_format_dict__):
+def download_file_from_internet_uncompress_file(url, headers=geturls_headers_pyfile_python_alt, filestart=0, formatspecs=__file_format_dict__):
     fp = download_file_from_internet_file(url)
-    fp = UncompressFileAlt(fp, formatspecs)
+    fp = UncompressFileAlt(fp, formatspecs, filestart)
     fp.seek(0, 0)
     if(not fp):
         return False
@@ -9848,7 +9516,7 @@ def download_file_from_internet_string(url, headers=geturls_headers_pyfile_pytho
         return download_file_from_http_string(url, headers)
     elif(urlparts.scheme == "ftp" or urlparts.scheme == "ftps"):
         return download_file_from_ftp_string(url)
-    elif(urlparts.scheme == "sftp"):
+    elif(urlparts.scheme == "sftp" or urlparts.scheme == "scp"):
         if(__use_pysftp__ and havepysftp):
             return download_file_from_pysftp_string(url)
         else:
@@ -9858,13 +9526,15 @@ def download_file_from_internet_string(url, headers=geturls_headers_pyfile_pytho
     return False
 
 
-def download_file_from_internet_uncompress_string(url, headers=geturls_headers_pyfile_python_alt, formatspecs=__file_format_dict__):
+def download_file_from_internet_uncompress_string(url, headers=geturls_headers_pyfile_python_alt, filestart=0, formatspecs=__file_format_dict__):
     fp = download_file_from_internet_string(url)
-    fp = UncompressFileAlt(fp, formatspecs)
-    fp.seek(0, 0)
+    fp = UncompressFileAlt(fp, formatspecs, filestart)
     if(not fp):
         return False
-    return fp
+    fp.seek(0, 0)
+    fpout = fp.read()
+    fp.close
+    return fpout
 
 
 def upload_file_to_internet_file(ifp, url):
@@ -9873,7 +9543,7 @@ def upload_file_to_internet_file(ifp, url):
         return False
     elif(urlparts.scheme == "ftp" or urlparts.scheme == "ftps"):
         return upload_file_to_ftp_file(ifp, url)
-    elif(urlparts.scheme == "sftp"):
+    elif(urlparts.scheme == "sftp" or urlparts.scheme == "scp"):
         if(__use_pysftp__ and havepysftp):
             return upload_file_to_pysftp_file(ifp, url)
         else:
@@ -9889,8 +9559,7 @@ def upload_file_to_internet_compress_file(ifp, url, compression="auto", compress
     if(not foxfileout):
         return False
     fp.seek(0, 0)
-    upload_file_to_internet_file(fp, outfile)
-    return True
+    return upload_file_to_internet_file(fp, outfile)
 
 
 def upload_file_to_internet_string(ifp, url):
@@ -9899,7 +9568,7 @@ def upload_file_to_internet_string(ifp, url):
         return False
     elif(urlparts.scheme == "ftp" or urlparts.scheme == "ftps"):
         return upload_file_to_ftp_string(ifp, url)
-    elif(urlparts.scheme == "sftp"):
+    elif(urlparts.scheme == "sftp" or urlparts.scheme == "scp"):
         if(__use_pysftp__ and havepysftp):
             return upload_file_to_pysftp_string(ifp, url)
         else:
@@ -9916,5 +9585,4 @@ def upload_file_to_internet_compress_string(ifp, url, compression="auto", compre
     if(not foxfileout):
         return False
     fp.seek(0, 0)
-    upload_file_to_internet_file(fp, outfile)
-    return True
+    return upload_file_to_internet_file(fp, outfile)