func (z *TzArchive) Close() (err error) {
	if err = z.Flush(); err != nil {
		return err
	}
	if z.ReadCloser != nil {
		if err = z.ReadCloser.Close(); err != nil {
			return err
		}
		z.ReadCloser = nil
	}
	return nil
}
Close opens or creates archive and save changes.
package tz
import (
	"archive/tar"
	"compress/gzip"
	"fmt"
	"io"
	"os"
	"path"
	"path/filepath"
	"strings"
	"github.com/unknwon/cae"
)
var Verbose = true
func extractFile(f *tar.Header, tr *tar.Reader, destPath string) error {
	filePath := path.Join(destPath, f.Name)
	os.MkdirAll(path.Dir(filePath), os.ModePerm)
	fw, err := os.Create(filePath)
	if err != nil {
		return err
	}
	defer fw.Close()
	if _, err = io.Copy(fw, tr); err != nil {
		return err
	}
	if f.FileInfo().Mode()&os.ModeSymlink != 0 {
		return nil
	}
	if err = os.Chtimes(filePath, f.FileInfo().ModTime(), f.FileInfo().ModTime()); err != nil {
		return err
	}
	return os.Chmod(filePath, f.FileInfo().Mode())
}
var defaultExtractFunc = func(fullName string, fi os.FileInfo) error {
	if !Verbose {
		return nil
	}
	fmt.Println("Extracting file..." + fullName)
	return nil
}
func (tz *TzArchive) ExtractToFunc(destPath string, fn cae.HookFunc, entries ...string) (err error) {
	destPath = strings.ReplaceAll(destPath, "\\", "/")
	isHasEntry := len(entries) > 0
	if Verbose {
		fmt.Println("Extracting " + tz.FileName + "...")
	}
	os.MkdirAll(destPath, os.ModePerm)
	for _, f := range tz.files {
		if !cae.IsExist(f.absPath) {
			continue
		}
		relPath := path.Join(destPath, f.Name)
		os.MkdirAll(path.Dir(relPath), os.ModePerm)
		if err := cae.Copy(relPath, f.absPath); err != nil {
			return err
		}
	}
	tr, f, err := openFile(tz.FileName)
	if err != nil {
		return err
	}
	defer f.Close()
	for {
		h, err := tr.Next()
		if err == io.EOF {
			break
		} else if err != nil {
			return err
		}
		h.Name = cae.Clean(strings.ReplaceAll(h.Name, "\\", "/"))
		if h.Typeflag == tar.TypeDir {
			if isHasEntry {
				if cae.IsEntry(h.Name, entries) {
					if err = fn(h.Name, h.FileInfo()); err != nil {
						continue
					}
					os.MkdirAll(path.Join(destPath, h.Name), os.ModePerm)
				}
				continue
			}
			if err = fn(h.Name, h.FileInfo()); err != nil {
				continue
			}
			os.MkdirAll(path.Join(destPath, h.Name), os.ModePerm)
			continue
		}
		if isHasEntry {
			if cae.IsEntry(h.Name, entries) {
				if err = fn(h.Name, h.FileInfo()); err != nil {
					continue
				}
				err = extractFile(h, tr, destPath)
			}
		} else {
			if err = fn(h.Name, h.FileInfo()); err != nil {
				continue
			}
			err = extractFile(h, tr, destPath)
		}
		if err != nil {
			return err
		}
	}
	return nil
}
func (tz *TzArchive) ExtractTo(destPath string, entries ...string) (err error) {
	return tz.ExtractToFunc(destPath, defaultExtractFunc, entries...)
}
func ExtractTo(srcPath, destPath string, entries ...string) (err error) {
	tz, err := Open(srcPath)
	if err != nil {
		return err
	}
	defer tz.Close()
	return tz.ExtractToFunc(destPath, defaultExtractFunc, entries...)
}
func (tz *TzArchive) extractFile(f *File, tr *tar.Reader) error {
	if !tz.isHasWriter {
		for _, h := range tz.ReadCloser.File {
			if f.Name == h.Name {
				return extractFile(h, tr, f.absPath)
			}
		}
	}
	return cae.Copy(f.Name, f.absPath)
}
func (tz *TzArchive) Flush() (err error) {
	if !tz.isHasChanged || (tz.ReadCloser == nil && !tz.isHasWriter) {
		return nil
	}
	tmpPath := filepath.Join(os.TempDir(), "cae", filepath.Base(tz.FileName))
	_ = os.RemoveAll(tmpPath)
	_ = os.MkdirAll(tmpPath, os.ModePerm)
	defer func() { _ = os.RemoveAll(tmpPath) }()
	for _, f := range tz.files {
		if strings.HasSuffix(f.Name, "/") {
			_ = os.MkdirAll(filepath.Join(tmpPath, f.Name), os.ModePerm)
			continue
		} else if !cae.IsExist(f.absPath) {
			continue
		}
		relPath := filepath.Join(tmpPath, f.Name)
		_ = os.MkdirAll(filepath.Dir(relPath), os.ModePerm)
		if err := cae.Copy(relPath, f.absPath); err != nil {
			return err
		}
	}
	if !tz.isHasWriter {
		tz.ReadCloser, err = openReader(tz.FileName)
		if err != nil {
			return err
		}
		tz.syncFiles()
		tr, f, err := openFile(tz.FileName)
		if err != nil {
			return err
		}
		defer f.Close()
		i := 0
		for {
			h, err := tr.Next()
			if err == io.EOF {
				break
			} else if err != nil {
				return err
			}
			if h.Typeflag == tar.TypeDir {
				os.MkdirAll(path.Join(tmpPath, h.Name), os.ModePerm)
				continue
			}
			fileName := tz.files[i].Name
			tz.files[i].Name = path.Join(tmpPath, fileName)
			if err := tz.extractFile(tz.files[i], tr); err != nil {
				return err
			}
			tz.files[i].Name = fileName
			i++
		}
	}
	if tz.isHasWriter {
		return packToWriter(tmpPath, tz.writer, defaultPackFunc, true)
	}
	if err := PackTo(tmpPath, tz.FileName); err != nil {
		return err
	}
	return tz.Open(tz.FileName, os.O_RDWR|os.O_TRUNC, tz.Permission)
}
func packFile(srcFile string, recPath string, tw *tar.Writer, fi os.FileInfo) (err error) {
	if fi.IsDir() {
		h, err := tar.FileInfoHeader(fi, "")
		if err != nil {
			return err
		}
		h.Name = recPath + "/"
		if err = tw.WriteHeader(h); err != nil {
			return err
		}
	} else {
		target := ""
		if fi.Mode()&os.ModeSymlink != 0 {
			target, err = os.Readlink(srcFile)
			if err != nil {
				return err
			}
		}
		h, err := tar.FileInfoHeader(fi, target)
		if err != nil {
			return err
		}
		h.Name = recPath
		if err = tw.WriteHeader(h); err != nil {
			return err
		}
		if len(target) == 0 {
			f, err := os.Open(srcFile)
			if err != nil {
				return err
			}
			if _, err = io.Copy(tw, f); err != nil {
				return err
			}
		}
	}
	return nil
}
func packDir(srcPath string, recPath string, tw *tar.Writer, fn cae.HookFunc) error {
	dir, err := os.Open(srcPath)
	if err != nil {
		return err
	}
	defer dir.Close()
	fis, err := dir.Readdir(0)
	if err != nil {
		return err
	}
	for _, fi := range fis {
		if cae.IsFilter(fi.Name()) {
			continue
		}
		curPath := srcPath + "/" + fi.Name()
		tmpRecPath := filepath.Join(recPath, fi.Name())
		if err = fn(curPath, fi); err != nil {
			continue
		}
		if fi.IsDir() {
			if err = packFile(srcPath, tmpRecPath, tw, fi); err != nil {
				return err
			}
			err = packDir(curPath, tmpRecPath, tw, fn)
		} else {
			err = packFile(curPath, tmpRecPath, tw, fi)
		}
		if err != nil {
			return err
		}
	}
	return nil
}
func packToWriter(srcPath string, w io.Writer, fn func(fullName string, fi os.FileInfo) error, includeDir bool) error {
	gw := gzip.NewWriter(w)
	defer gw.Close()
	tw := tar.NewWriter(gw)
	defer tw.Close()
	f, err := os.Open(srcPath)
	if err != nil {
		return err
	}
	fi, err := f.Stat()
	if err != nil {
		return err
	}
	basePath := filepath.Base(srcPath)
	if fi.IsDir() {
		if includeDir {
			if err = packFile(srcPath, basePath, tw, fi); err != nil {
				return err
			}
		} else {
			basePath = ""
		}
		return packDir(srcPath, basePath, tw, fn)
	}
	return packFile(srcPath, basePath, tw, fi)
}
func packTo(srcPath, destPath string, fn cae.HookFunc, includeDir bool) error {
	fw, err := os.Create(destPath)
	if err != nil {
		return err
	}
	defer fw.Close()
	return packToWriter(srcPath, fw, fn, includeDir)
}
func PackToFunc(srcPath, destPath string, fn func(fullName string, fi os.FileInfo) error, includeDir ...bool) error {
	isIncludeDir := false
	if len(includeDir) > 0 && includeDir[0] {
		isIncludeDir = true
	}
	return packTo(srcPath, destPath, fn, isIncludeDir)
}
var defaultPackFunc = func(fullName string, fi os.FileInfo) error {
	if !Verbose {
		return nil
	}
	if fi.IsDir() {
		fmt.Printf("Adding dir...%s\n", fullName)
	} else {
		fmt.Printf("Adding file...%s\n", fullName)
	}
	return nil
}
func PackTo(srcPath, destPath string, includeDir ...bool) error {
	return PackToFunc(srcPath, destPath, defaultPackFunc, includeDir...)
}