Merge Dtf

17 files changed, 3816 insertions, 0 deletions

diff --git a/src/dtf/WixToolset.Dtf.Compression/ArchiveException.cs b/src/dtf/WixToolset.Dtf.Compression/ArchiveException.cs
new file mode 100644
index 00000000..a53e862c
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression/ArchiveException.cs
@@ -0,0 +1,57 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression
+{
+    using System;
+    using System.IO;
+    using System.Runtime.Serialization;
+
+    /// <summary>
+    /// Base exception class for compression operations. Compression libraries should
+    /// derive subclass exceptions with more specific error information relevent to the
+    /// file format.
+    /// </summary>
+    [Serializable]
+    public class ArchiveException : IOException
+    {
+        /// <summary>
+        /// Creates a new ArchiveException with a specified error message and a reference to the
+        /// inner exception that is the cause of this exception.
+        /// </summary>
+        /// <param name="message">The message that describes the error.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception. If the
+        /// innerException parameter is not a null reference (Nothing in Visual Basic), the current exception
+        /// is raised in a catch block that handles the inner exception.</param>
+        public ArchiveException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new ArchiveException with a specified error message.
+        /// </summary>
+        /// <param name="message">The message that describes the error.</param>
+        public ArchiveException(string message)
+            : this(message, null)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new ArchiveException.
+        /// </summary>
+        public ArchiveException()
+            : this(null, null)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the ArchiveException class with serialized data.
+        /// </summary>
+        /// <param name="info">The SerializationInfo that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The StreamingContext that contains contextual information about the source or destination.</param>
+        protected ArchiveException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression/ArchiveFileInfo.cs b/src/dtf/WixToolset.Dtf.Compression/ArchiveFileInfo.cs
new file mode 100644
index 00000000..adcae3ec
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression/ArchiveFileInfo.cs
@@ -0,0 +1,430 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression
+{
+    using System;
+    using System.IO;
+    using System.Runtime.Serialization;
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// Abstract object representing a compressed file within an archive;
+    /// provides operations for getting the file properties and unpacking
+    /// the file.
+    /// </summary>
+    [Serializable]
+    public abstract class ArchiveFileInfo : FileSystemInfo
+    {
+        private ArchiveInfo archiveInfo;
+        private string name;
+        private string path;
+
+        private bool initialized;
+        private bool exists;
+        private int archiveNumber;
+        private FileAttributes attributes;
+        private DateTime lastWriteTime;
+        private long length;
+
+        /// <summary>
+        /// Creates a new ArchiveFileInfo object representing a file within
+        /// an archive in a specified path.
+        /// </summary>
+        /// <param name="archiveInfo">An object representing the archive
+        /// containing the file.</param>
+        /// <param name="filePath">The path to the file within the archive.
+        /// Usually, this is a simple file name, but if the archive contains
+        /// a directory structure this may include the directory.</param>
+        protected ArchiveFileInfo(ArchiveInfo archiveInfo, string filePath)
+            : base()
+        {
+            if (filePath == null)
+            {
+                throw new ArgumentNullException("filePath");
+            }
+
+            this.Archive = archiveInfo;
+
+            this.name = System.IO.Path.GetFileName(filePath);
+            this.path = System.IO.Path.GetDirectoryName(filePath);
+
+            this.attributes = FileAttributes.Normal;
+            this.lastWriteTime = DateTime.MinValue;
+        }
+
+        /// <summary>
+        /// Creates a new ArchiveFileInfo object with all parameters specified;
+        /// used by subclasses when reading the metadata out of an archive.
+        /// </summary>
+        /// <param name="filePath">The internal path and name of the file in
+        /// the archive.</param>
+        /// <param name="archiveNumber">The archive number where the file
+        /// starts.</param>
+        /// <param name="attributes">The stored attributes of the file.</param>
+        /// <param name="lastWriteTime">The stored last write time of the
+        /// file.</param>
+        /// <param name="length">The uncompressed size of the file.</param>
+        protected ArchiveFileInfo(
+            string filePath,
+            int archiveNumber,
+            FileAttributes attributes,
+            DateTime lastWriteTime,
+            long length)
+            : this(null, filePath)
+        {
+            this.exists = true;
+            this.archiveNumber = archiveNumber;
+            this.attributes = attributes;
+            this.lastWriteTime = lastWriteTime;
+            this.length = length;
+            this.initialized = true;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the ArchiveFileInfo class with
+        /// serialized data.
+        /// </summary>
+        /// <param name="info">The SerializationInfo that holds the serialized
+        /// object data about the exception being thrown.</param>
+        /// <param name="context">The StreamingContext that contains contextual
+        /// information about the source or destination.</param>
+        protected ArchiveFileInfo(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+            this.archiveInfo = (ArchiveInfo) info.GetValue(
+                "archiveInfo", typeof(ArchiveInfo));
+            this.name = info.GetString("name");
+            this.path = info.GetString("path");
+            this.initialized = info.GetBoolean("initialized");
+            this.exists = info.GetBoolean("exists");
+            this.archiveNumber = info.GetInt32("archiveNumber");
+            this.attributes = (FileAttributes) info.GetValue(
+                "attributes", typeof(FileAttributes));
+            this.lastWriteTime = info.GetDateTime("lastWriteTime");
+            this.length = info.GetInt64("length");
+        }
+
+        /// <summary>
+        /// Gets the name of the file.
+        /// </summary>
+        /// <value>The name of the file, not including any path.</value>
+        public override string Name
+        {
+            get
+            {
+                return this.name;
+            }
+        }
+
+        /// <summary>
+        /// Gets the internal path of the file in the archive.
+        /// </summary>
+        /// <value>The internal path of the file in the archive, not including
+        /// the file name.</value>
+        public string Path
+        {
+            get
+            {
+                return this.path;
+            }
+        }
+
+        /// <summary>
+        /// Gets the full path to the file.
+        /// </summary>
+        /// <value>The full path to the file, including the full path to the
+        /// archive, the internal path in the archive, and the file name.</value>
+        /// <remarks>
+        /// For example, the path <c>"C:\archive.cab\file.txt"</c> refers to
+        /// a file "file.txt" inside the archive "archive.cab".
+        /// </remarks>
+        public override string FullName
+        {
+            get
+            {
+                string fullName = System.IO.Path.Combine(this.Path, this.Name);
+                
+                if (this.Archive != null)
+                {
+                    fullName = System.IO.Path.Combine(this.ArchiveName, fullName);
+                }
+
+                return fullName;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the archive that contains this file.
+        /// </summary>
+        /// <value>
+        /// The ArchiveInfo instance that retrieved this file information -- this
+        /// may be null if the ArchiveFileInfo object was returned directly from
+        /// a stream.
+        /// </value>
+        public ArchiveInfo Archive
+        {
+            get
+            {
+                return (ArchiveInfo) this.archiveInfo;
+            }
+
+            internal set
+            {
+                this.archiveInfo = value;
+
+                // protected instance members inherited from FileSystemInfo:
+                this.OriginalPath = (value != null ? value.FullName : null);
+                this.FullPath = this.OriginalPath;
+            }
+        }
+
+        /// <summary>
+        /// Gets the full path of the archive that contains this file.
+        /// </summary>
+        /// <value>The full path of the archive that contains this file.</value>
+        public string ArchiveName
+        {
+            get
+            {
+                return this.Archive != null ? this.Archive.FullName : null;
+            }
+        }
+
+        /// <summary>
+        /// Gets the number of the archive where this file starts.
+        /// </summary>
+        /// <value>The number of the archive where this file starts.</value>
+        /// <remarks>A single archive or the first archive in a chain is
+        /// numbered 0.</remarks>
+        public int ArchiveNumber
+        {
+            get
+            {
+                return this.archiveNumber;
+            }
+        }
+
+        /// <summary>
+        /// Checks if the file exists within the archive.
+        /// </summary>
+        /// <value>True if the file exists, false otherwise.</value>
+        public override bool Exists
+        {
+            get
+            {
+                if (!this.initialized)
+                {
+                    this.Refresh();
+                }
+
+                return this.exists;
+            }
+        }
+
+        /// <summary>
+        /// Gets the uncompressed size of the file.
+        /// </summary>
+        /// <value>The uncompressed size of the file in bytes.</value>
+        public long Length
+        {
+            get
+            {
+                if (!this.initialized)
+                {
+                    this.Refresh();
+                }
+
+                return this.length;
+            }
+        }
+
+        /// <summary>
+        /// Gets the attributes of the file.
+        /// </summary>
+        /// <value>The attributes of the file as stored in the archive.</value>
+        public new FileAttributes Attributes
+        {
+            get
+            {
+                if (!this.initialized)
+                {
+                    this.Refresh();
+                }
+
+                return this.attributes;
+            }
+        }
+
+        /// <summary>
+        /// Gets the last modification time of the file.
+        /// </summary>
+        /// <value>The last modification time of the file as stored in the
+        /// archive.</value>
+        public new DateTime LastWriteTime
+        {
+            get
+            {
+                if (!this.initialized)
+                {
+                    this.Refresh();
+                }
+
+                return this.lastWriteTime;
+            }
+        }
+
+        /// <summary>
+        /// Sets the SerializationInfo with information about the archive.
+        /// </summary>
+        /// <param name="info">The SerializationInfo that holds the serialized
+        /// object data.</param>
+        /// <param name="context">The StreamingContext that contains contextual
+        /// information about the source or destination.</param>
+        public override void GetObjectData(
+            SerializationInfo info, StreamingContext context)
+        {
+            base.GetObjectData(info, context);
+            info.AddValue("archiveInfo", this.archiveInfo);
+            info.AddValue("name", this.name);
+            info.AddValue("path", this.path);
+            info.AddValue("initialized", this.initialized);
+            info.AddValue("exists", this.exists);
+            info.AddValue("archiveNumber", this.archiveNumber);
+            info.AddValue("attributes", this.attributes);
+            info.AddValue("lastWriteTime", this.lastWriteTime);
+            info.AddValue("length", this.length);
+        }
+
+        /// <summary>
+        /// Gets the full path to the file.
+        /// </summary>
+        /// <returns>The same as <see cref="FullName"/></returns>
+        public override string ToString()
+        {
+            return this.FullName;
+        }
+
+        /// <summary>
+        /// Deletes the file. NOT SUPPORTED.
+        /// </summary>
+        /// <exception cref="NotSupportedException">Files cannot be deleted
+        /// from an existing archive.</exception>
+        public override void Delete()
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Refreshes the attributes and other cached information about the file,
+        /// by re-reading the information from the archive.
+        /// </summary>
+        public new void Refresh()
+        {
+            base.Refresh();
+
+            if (this.Archive != null)
+            {
+                string filePath = System.IO.Path.Combine(this.Path, this.Name);
+                ArchiveFileInfo updatedFile = this.Archive.GetFile(filePath);
+                if (updatedFile == null)
+                {
+                    throw new FileNotFoundException(
+                            "File not found in archive.", filePath);
+                }
+
+                this.Refresh(updatedFile);
+            }
+        }
+
+        /// <summary>
+        /// Extracts the file.
+        /// </summary>
+        /// <param name="destFileName">The destination path where the file
+        /// will be extracted.</param>
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "dest")]
+        public void CopyTo(string destFileName)
+        {
+            this.CopyTo(destFileName, false);
+        }
+
+        /// <summary>
+        /// Extracts the file, optionally overwriting any existing file.
+        /// </summary>
+        /// <param name="destFileName">The destination path where the file
+        /// will be extracted.</param>
+        /// <param name="overwrite">If true, <paramref name="destFileName"/>
+        /// will be overwritten if it exists.</param>
+        /// <exception cref="IOException"><paramref name="overwrite"/> is false
+        /// and <paramref name="destFileName"/> exists.</exception>
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "dest")]
+        public void CopyTo(string destFileName, bool overwrite)
+        {
+            if (destFileName == null)
+            {
+                throw new ArgumentNullException("destFileName");
+            }
+
+            if (!overwrite && File.Exists(destFileName))
+            {
+                throw new IOException();
+            }
+
+            if (this.Archive == null)
+            {
+                throw new InvalidOperationException();
+            }
+
+            this.Archive.UnpackFile(
+                System.IO.Path.Combine(this.Path, this.Name), destFileName);
+        }
+
+        /// <summary>
+        /// Opens the archive file for reading without actually extracting the
+        /// file to disk.
+        /// </summary>
+        /// <returns>
+        /// A stream for reading directly from the packed file. Like any stream
+        /// this should be closed/disposed as soon as it is no longer needed.
+        /// </returns>
+        public Stream OpenRead()
+        {
+            return this.Archive.OpenRead(System.IO.Path.Combine(this.Path, this.Name));
+        }
+
+        /// <summary>
+        /// Opens the archive file reading text with UTF-8 encoding without
+        /// actually extracting the file to disk.
+        /// </summary>
+        /// <returns>
+        /// A reader for reading text directly from the packed file. Like any reader
+        /// this should be closed/disposed as soon as it is no longer needed.
+        /// </returns>
+        /// <remarks>
+        /// To open an archived text file with different encoding, use the
+        /// <see cref="OpenRead" /> method and pass the returned stream to one of
+        /// the <see cref="StreamReader" /> constructor overloads.
+        /// </remarks>
+        public StreamReader OpenText()
+        {
+            return this.Archive.OpenText(System.IO.Path.Combine(this.Path, this.Name));
+        }
+
+        /// <summary>
+        /// Refreshes the information in this object with new data retrieved
+        /// from an archive.
+        /// </summary>
+        /// <param name="newFileInfo">Fresh instance for the same file just
+        /// read from the archive.</param>
+        /// <remarks>
+        /// Subclasses may override this method to refresh sublcass fields.
+        /// However they should always call the base implementation first.
+        /// </remarks>
+        protected virtual void Refresh(ArchiveFileInfo newFileInfo)
+        {
+            this.exists = newFileInfo.exists;
+            this.length = newFileInfo.length;
+            this.attributes = newFileInfo.attributes;
+            this.lastWriteTime = newFileInfo.lastWriteTime;
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression/ArchiveFileStreamContext.cs b/src/dtf/WixToolset.Dtf.Compression/ArchiveFileStreamContext.cs
new file mode 100644
index 00000000..8be3bff4
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression/ArchiveFileStreamContext.cs
@@ -0,0 +1,664 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression
+{
+    using System;
+    using System.IO;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Provides a basic implementation of the archive pack and unpack stream context
+    /// interfaces, based on a list of archive files, a default directory, and an
+    /// optional mapping from internal to external file paths.
+    /// </summary>
+    /// <remarks>
+    /// This class can also handle creating or extracting chained archive packages.
+    /// </remarks>
+    public class ArchiveFileStreamContext
+        : IPackStreamContext, IUnpackStreamContext
+    {
+        private IList<string> archiveFiles;
+        private string directory;
+        private IDictionary<string, string> files;
+        private bool extractOnlyNewerFiles;
+        private bool enableOffsetOpen;
+
+        #region Constructors
+
+        /// <summary>
+        /// Creates a new ArchiveFileStreamContext with a archive file and
+        /// no default directory or file mapping.
+        /// </summary>
+        /// <param name="archiveFile">The path to a archive file that will be
+        /// created or extracted.</param>
+        public ArchiveFileStreamContext(string archiveFile)
+            : this(archiveFile, null, null)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new ArchiveFileStreamContext with a archive file, default
+        /// directory and mapping from internal to external file paths.
+        /// </summary>
+        /// <param name="archiveFile">The path to a archive file that will be
+        /// created or extracted.</param>
+        /// <param name="directory">The default root directory where files will be
+        /// located, optional.</param>
+        /// <param name="files">A mapping from internal file paths to external file
+        /// paths, optional.</param>
+        /// <remarks>
+        /// If the mapping is not null and a file is not included in the mapping,
+        /// the file will be skipped.
+        /// <para>If the external path in the mapping is a simple file name or
+        /// relative file path, it will be concatenated onto the default directory,
+        /// if one was specified.</para>
+        /// <para>For more about how the default directory and files mapping are
+        /// used, see <see cref="OpenFileReadStream"/> and
+        /// <see cref="OpenFileWriteStream"/>.</para>
+        /// </remarks>
+        public ArchiveFileStreamContext(
+            string archiveFile,
+            string directory,
+            IDictionary<string, string> files)
+            : this(new string[] { archiveFile }, directory, files)
+        {
+            if (archiveFile == null)
+            {
+                throw new ArgumentNullException("archiveFile");
+            }
+        }
+
+        /// <summary>
+        /// Creates a new ArchiveFileStreamContext with a list of archive files,
+        /// a default directory and a mapping from internal to external file paths.
+        /// </summary>
+        /// <param name="archiveFiles">A list of paths to archive files that will be
+        /// created or extracted.</param>
+        /// <param name="directory">The default root directory where files will be
+        /// located, optional.</param>
+        /// <param name="files">A mapping from internal file paths to external file
+        /// paths, optional.</param>
+        /// <remarks>
+        /// When creating chained archives, the <paramref name="archiveFiles"/> list
+        /// should include at least enough archives to handle the entire set of
+        /// input files, based on the maximum archive size that is passed to the
+        /// <see cref="CompressionEngine"/>.<see
+        /// cref="CompressionEngine.Pack(IPackStreamContext,IEnumerable&lt;string&gt;,long)"/>.
+        /// <para>If the mapping is not null and a file is not included in the mapping,
+        /// the file will be skipped.</para>
+        /// <para>If the external path in the mapping is a simple file name or
+        /// relative file path, it will be concatenated onto the default directory,
+        /// if one was specified.</para>
+        /// <para>For more about how the default directory and files mapping are used,
+        /// see <see cref="OpenFileReadStream"/> and
+        /// <see cref="OpenFileWriteStream"/>.</para>
+        /// </remarks>
+        public ArchiveFileStreamContext(
+            IList<string> archiveFiles,
+            string directory,
+            IDictionary<string, string> files)
+        {
+            if (archiveFiles == null || archiveFiles.Count == 0)
+            {
+                throw new ArgumentNullException("archiveFiles");
+            }
+
+            this.archiveFiles = archiveFiles;
+            this.directory = directory;
+            this.files = files;
+        }
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Gets or sets the list of archive files that are created or extracted.
+        /// </summary>
+        /// <value>The list of archive files that are created or extracted.</value>
+        public IList<string> ArchiveFiles
+        {
+            get
+            {
+                return this.archiveFiles;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the default root directory where files are located.
+        /// </summary>
+        /// <value>The default root directory where files are located.</value>
+        /// <remarks>
+        /// For details about how the default directory is used,
+        /// see <see cref="OpenFileReadStream"/> and <see cref="OpenFileWriteStream"/>.
+        /// </remarks>
+        public string Directory
+        {
+            get
+            {
+                return this.directory;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the mapping from internal file paths to external file paths.
+        /// </summary>
+        /// <value>A mapping from internal file paths to external file paths.</value>
+        /// <remarks>
+        /// For details about how the files mapping is used,
+        /// see <see cref="OpenFileReadStream"/> and <see cref="OpenFileWriteStream"/>.
+        /// </remarks>
+        public IDictionary<string, string> Files
+        {
+            get
+            {
+                return this.files;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a flag that can prevent extracted files from overwriting
+        /// newer files that already exist.
+        /// </summary>
+        /// <value>True to prevent overwriting newer files that already exist
+        /// during extraction; false to always extract from the archive regardless
+        /// of existing files.</value>
+        public bool ExtractOnlyNewerFiles
+        {
+            get
+            {
+                return this.extractOnlyNewerFiles;
+            }
+
+            set
+            {
+                this.extractOnlyNewerFiles = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a flag that enables creating or extracting an archive
+        /// at an offset within an existing file. (This is typically used to open
+        /// archive-based self-extracting packages.)
+        /// </summary>
+        /// <value>True to search an existing package file for an archive offset
+        /// or the end of the file;/ false to always create or open a plain
+        /// archive file.</value>
+        public bool EnableOffsetOpen
+        {
+            get
+            {
+                return this.enableOffsetOpen;
+            }
+
+            set
+            {
+                this.enableOffsetOpen = value;
+            }
+        }
+
+        #endregion
+
+        #region IPackStreamContext Members
+
+        /// <summary>
+        /// Gets the name of the archive with a specified number.
+        /// </summary>
+        /// <param name="archiveNumber">The 0-based index of the archive within
+        /// the chain.</param>
+        /// <returns>The name of the requested archive. May be an empty string
+        /// for non-chained archives, but may never be null.</returns>
+        /// <remarks>This method returns the file name of the archive from the
+        /// <see cref="archiveFiles"/> list with the specified index, or an empty
+        /// string if the archive number is outside the bounds of the list. The
+        /// file name should not include any directory path.</remarks>
+        public virtual string GetArchiveName(int archiveNumber)
+        {
+            if (archiveNumber < this.archiveFiles.Count)
+            {
+                return Path.GetFileName(this.archiveFiles[archiveNumber]);
+            }
+
+            return String.Empty;
+        }
+
+        /// <summary>
+        /// Opens a stream for writing an archive.
+        /// </summary>
+        /// <param name="archiveNumber">The 0-based index of the archive within
+        /// the chain.</param>
+        /// <param name="archiveName">The name of the archive that was returned
+        /// by <see cref="GetArchiveName"/>.</param>
+        /// <param name="truncate">True if the stream should be truncated when
+        /// opened (if it already exists); false if an existing stream is being
+        /// re-opened for writing additional data.</param>
+        /// <param name="compressionEngine">Instance of the compression engine
+        /// doing the operations.</param>
+        /// <returns>A writable Stream where the compressed archive bytes will be
+        /// written, or null to cancel the archive creation.</returns>
+        /// <remarks>
+        /// This method opens the file from the <see cref="ArchiveFiles"/> list
+        /// with the specified index. If the archive number is outside the bounds
+        /// of the list, this method returns null.
+        /// <para>If the <see cref="EnableOffsetOpen"/> flag is set, this method
+        /// will seek to the start of any existing archive in the file, or to the
+        /// end of the file if the existing file is not an archive.</para>
+        /// </remarks>
+        public virtual Stream OpenArchiveWriteStream(
+            int archiveNumber,
+            string archiveName,
+            bool truncate,
+            CompressionEngine compressionEngine)
+        {
+            if (archiveNumber >= this.archiveFiles.Count)
+            {
+                return null;
+            }
+
+            if (String.IsNullOrEmpty(archiveName))
+            {
+                throw new ArgumentNullException("archiveName");
+            }
+
+            // All archives must be in the same directory,
+            // so always use the directory from the first archive.
+            string archiveFile = Path.Combine(
+                Path.GetDirectoryName(this.archiveFiles[0]), archiveName);
+            Stream stream = File.Open(
+                archiveFile,
+                (truncate ? FileMode.OpenOrCreate : FileMode.Open),
+                FileAccess.ReadWrite);
+
+            if (this.enableOffsetOpen)
+            {
+                long offset = compressionEngine.FindArchiveOffset(
+                    new DuplicateStream(stream));
+
+                // If this is not an archive file, append the archive to it.
+                if (offset < 0)
+                {
+                    offset = stream.Length;
+                }
+
+                if (offset > 0)
+                {
+                    stream = new OffsetStream(stream, offset);
+                }
+
+                stream.Seek(0, SeekOrigin.Begin);
+            }
+
+            if (truncate)
+            {
+                // Truncate the stream, in case a larger old archive starts here.
+                stream.SetLength(0);
+            }
+            
+            return stream;
+        }
+
+        /// <summary>
+        /// Closes a stream where an archive package was written.
+        /// </summary>
+        /// <param name="archiveNumber">The 0-based index of the archive within
+        /// the chain.</param>
+        /// <param name="archiveName">The name of the archive that was previously
+        /// returned by <see cref="GetArchiveName"/>.</param>
+        /// <param name="stream">A stream that was previously returned by
+        /// <see cref="OpenArchiveWriteStream"/> and is now ready to be closed.</param>
+        public virtual void CloseArchiveWriteStream(
+            int archiveNumber,
+            string archiveName,
+            Stream stream)
+        {
+            if (stream != null)
+            {
+                stream.Close();
+
+                FileStream fileStream = stream as FileStream;
+                if (fileStream != null)
+                {
+                    string streamFile = fileStream.Name;
+                    if (!String.IsNullOrEmpty(archiveName) &&
+                        archiveName != Path.GetFileName(streamFile))
+                    {
+                        string archiveFile = Path.Combine(
+                            Path.GetDirectoryName(this.archiveFiles[0]), archiveName);
+                        if (File.Exists(archiveFile))
+                        {
+                            File.Delete(archiveFile);
+                        }
+                        File.Move(streamFile, archiveFile);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Opens a stream to read a file that is to be included in an archive.
+        /// </summary>
+        /// <param name="path">The path of the file within the archive.</param>
+        /// <param name="attributes">The returned attributes of the opened file,
+        /// to be stored in the archive.</param>
+        /// <param name="lastWriteTime">The returned last-modified time of the
+        /// opened file, to be stored in the archive.</param>
+        /// <returns>A readable Stream where the file bytes will be read from
+        /// before they are compressed, or null to skip inclusion of the file and
+        /// continue to the next file.</returns>
+        /// <remarks>
+        /// This method opens a file using the following logic:
+        /// <list>
+        /// <item>If the <see cref="Directory"/> and the <see cref="Files"/> mapping
+        /// are both null, the path is treated as relative to the current directory,
+        /// and that file is opened.</item>
+        /// <item>If the <see cref="Directory"/> is not null but the <see cref="Files"/>
+        /// mapping is null, the path is treated as relative to that directory, and
+        /// that file is opened.</item>
+        /// <item>If the <see cref="Directory"/> is null but the <see cref="Files"/>
+        /// mapping is not null, the path parameter is used as a key into the mapping,
+        /// and the resulting value is the file path that is opened, relative to the
+        /// current directory (or it may be an absolute path). If no mapping exists,
+        /// the file is skipped.</item>
+        /// <item>If both the <see cref="Directory"/> and the <see cref="Files"/>
+        /// mapping are specified, the path parameter is used as a key into the
+        /// mapping, and the resulting value is the file path that is opened, relative
+        /// to the specified directory (or it may be an absolute path). If no mapping
+        /// exists, the file is skipped.</item>
+        /// </list>
+        /// </remarks>
+        public virtual Stream OpenFileReadStream(
+            string path, out FileAttributes attributes, out DateTime lastWriteTime)
+        {
+            string filePath = this.TranslateFilePath(path);
+
+            if (filePath == null)
+            {
+                attributes = FileAttributes.Normal;
+                lastWriteTime = DateTime.Now;
+                return null;
+            }
+
+            attributes = File.GetAttributes(filePath);
+            lastWriteTime = File.GetLastWriteTime(filePath);
+            return File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
+        }
+
+        /// <summary>
+        /// Closes a stream that has been used to read a file.
+        /// </summary>
+        /// <param name="path">The path of the file within the archive; the same as
+        /// the path provided when the stream was opened.</param>
+        /// <param name="stream">A stream that was previously returned by
+        /// <see cref="OpenFileReadStream"/> and is now ready to be closed.</param>
+        public virtual void CloseFileReadStream(string path, Stream stream)
+        {
+            if (stream != null)
+            {
+                stream.Close();
+            }
+        }
+
+        /// <summary>
+        /// Gets extended parameter information specific to the compression format
+        /// being used.
+        /// </summary>
+        /// <param name="optionName">Name of the option being requested.</param>
+        /// <param name="parameters">Parameters for the option; for per-file options,
+        /// the first parameter is typically the internal file path.</param>
+        /// <returns>Option value, or null to use the default behavior.</returns>
+        /// <remarks>
+        /// This implementation does not handle any options. Subclasses may override
+        /// this method to allow for non-default behavior.
+        /// </remarks>
+        public virtual object GetOption(string optionName, object[] parameters)
+        {
+            return null;
+        }
+
+        #endregion
+
+        #region IUnpackStreamContext Members
+
+        /// <summary>
+        /// Opens the archive stream for reading.
+        /// </summary>
+        /// <param name="archiveNumber">The zero-based index of the archive to
+        /// open.</param>
+        /// <param name="archiveName">The name of the archive being opened.</param>
+        /// <param name="compressionEngine">Instance of the compression engine
+        /// doing the operations.</param>
+        /// <returns>A stream from which archive bytes are read, or null to cancel
+        /// extraction of the archive.</returns>
+        /// <remarks>
+        /// This method opens the file from the <see cref="ArchiveFiles"/> list with
+        /// the specified index. If the archive number is outside the bounds of the
+        /// list, this method returns null.
+        /// <para>If the <see cref="EnableOffsetOpen"/> flag is set, this method will
+        /// seek to the start of any existing archive in the file, or to the end of
+        /// the file if the existing file is not an archive.</para>
+        /// </remarks>
+        public virtual Stream OpenArchiveReadStream(
+            int archiveNumber, string archiveName, CompressionEngine compressionEngine)
+        {
+            if (archiveNumber >= this.archiveFiles.Count)
+            {
+                return null;
+            }
+
+            string archiveFile = this.archiveFiles[archiveNumber];
+            Stream stream = File.Open(
+                archiveFile, FileMode.Open, FileAccess.Read, FileShare.Read);
+
+            if (this.enableOffsetOpen)
+            {
+                long offset = compressionEngine.FindArchiveOffset(
+                    new DuplicateStream(stream));
+                if (offset > 0)
+                {
+                    stream = new OffsetStream(stream, offset);
+                }
+                else
+                {
+                    stream.Seek(0, SeekOrigin.Begin);
+                }
+            }
+
+            return stream;
+        }
+
+        /// <summary>
+        /// Closes a stream where an archive was read.
+        /// </summary>
+        /// <param name="archiveNumber">The archive number of the stream
+        /// to close.</param>
+        /// <param name="archiveName">The name of the archive being closed.</param>
+        /// <param name="stream">The stream that was previously returned by
+        /// <see cref="OpenArchiveReadStream"/> and is now ready to be closed.</param>
+        public virtual void CloseArchiveReadStream(
+            int archiveNumber, string archiveName, Stream stream)
+        {
+            if (stream != null)
+            {
+                stream.Close();
+            }
+        }
+
+        /// <summary>
+        /// Opens a stream for writing extracted file bytes.
+        /// </summary>
+        /// <param name="path">The path of the file within the archive.</param>
+        /// <param name="fileSize">The uncompressed size of the file to be
+        /// extracted.</param>
+        /// <param name="lastWriteTime">The last write time of the file to be
+        /// extracted.</param>
+        /// <returns>A stream where extracted file bytes are to be written, or null
+        /// to skip extraction of the file and continue to the next file.</returns>
+        /// <remarks>
+        /// This method opens a file using the following logic:
+        /// <list>
+        /// <item>If the <see cref="Directory"/> and the <see cref="Files"/> mapping
+        /// are both null, the path is treated as relative to the current directory,
+        /// and that file is opened.</item>
+        /// <item>If the <see cref="Directory"/> is not null but the <see cref="Files"/>
+        /// mapping is null, the path is treated as relative to that directory, and
+        /// that file is opened.</item>
+        /// <item>If the <see cref="Directory"/> is null but the <see cref="Files"/>
+        /// mapping is not null, the path parameter is used as a key into the mapping,
+        /// and the resulting value is the file path that is opened, relative to the
+        /// current directory (or it may be an absolute path). If no mapping exists,
+        /// the file is skipped.</item>
+        /// <item>If both the <see cref="Directory"/> and the <see cref="Files"/>
+        /// mapping are specified, the path parameter is used as a key into the
+        /// mapping, and the resulting value is the file path that is opened,
+        /// relative to the specified directory (or it may be an absolute path).
+        /// If no mapping exists, the file is skipped.</item>
+        /// </list>
+        /// <para>If the <see cref="ExtractOnlyNewerFiles"/> flag is set, the file
+        /// is skipped if a file currently exists in the same path with an equal
+        /// or newer write time.</para>
+        /// </remarks>
+        public virtual Stream OpenFileWriteStream(
+            string path,
+            long fileSize,
+            DateTime lastWriteTime)
+        {
+            string filePath = this.TranslateFilePath(path);
+
+            if (filePath == null)
+            {
+                return null;
+            }
+
+            FileInfo file = new FileInfo(filePath);
+            if (file.Exists)
+            {
+                if (this.extractOnlyNewerFiles && lastWriteTime != DateTime.MinValue)
+                {
+                    if (file.LastWriteTime >= lastWriteTime)
+                    {
+                        return null;
+                    }
+                }
+
+                // Clear attributes that will prevent overwriting the file.
+                // (The final attributes will be set after the file is unpacked.)
+                FileAttributes attributesToClear =
+                    FileAttributes.ReadOnly | FileAttributes.Hidden | FileAttributes.System;
+                if ((file.Attributes & attributesToClear) != 0)
+                {
+                    file.Attributes &= ~attributesToClear;
+                }
+            }
+
+            if (!file.Directory.Exists)
+            {
+                file.Directory.Create();
+            }
+
+            return File.Open(
+                filePath, FileMode.Create, FileAccess.Write, FileShare.None);
+        }
+
+        /// <summary>
+        /// Closes a stream where an extracted file was written.
+        /// </summary>
+        /// <param name="path">The path of the file within the archive.</param>
+        /// <param name="stream">The stream that was previously returned by
+        /// <see cref="OpenFileWriteStream"/> and is now ready to be closed.</param>
+        /// <param name="attributes">The attributes of the extracted file.</param>
+        /// <param name="lastWriteTime">The last write time of the file.</param>
+        /// <remarks>
+        /// After closing the extracted file stream, this method applies the date
+        /// and attributes to that file.
+        /// </remarks>
+        public virtual void CloseFileWriteStream(
+            string path,
+            Stream stream,
+            FileAttributes attributes,
+            DateTime lastWriteTime)
+        {
+            if (stream != null)
+            {
+                stream.Close();
+            }
+
+            string filePath = this.TranslateFilePath(path);
+            if (filePath != null)
+            {
+                FileInfo file = new FileInfo(filePath);
+
+                if (lastWriteTime != DateTime.MinValue)
+                {
+                    try
+                    {
+                        file.LastWriteTime = lastWriteTime;
+                    }
+                    catch (ArgumentException)
+                    {
+                    }
+                    catch (IOException)
+                    {
+                    }
+                }
+
+                try
+                {
+                    file.Attributes = attributes;
+                }
+                catch (IOException)
+                {
+                }
+            }
+        }
+
+        #endregion
+
+        #region Private utility methods
+
+        /// <summary>
+        /// Translates an internal file path to an external file path using the
+        /// <see cref="Directory"/> and the <see cref="Files"/> mapping, according to
+        /// rules documented in <see cref="OpenFileReadStream"/> and
+        /// <see cref="OpenFileWriteStream"/>.
+        /// </summary>
+        /// <param name="path">The path of the file with the archive.</param>
+        /// <returns>The external path of the file, or null if there is no
+        /// valid translation.</returns>
+        private string TranslateFilePath(string path)
+        {
+            string filePath;
+            if (this.files != null)
+            {
+                filePath = this.files[path];
+            }
+            else
+            {
+                this.ValidateArchivePath(path);
+
+                filePath = path;
+            }
+
+            if (filePath != null)
+            {
+                if (this.directory != null)
+                {
+                    filePath = Path.Combine(this.directory, filePath);
+                }
+            }
+
+            return filePath;
+        }
+
+        private void ValidateArchivePath(string filePath)
+        {
+            string basePath = Path.GetFullPath(String.IsNullOrEmpty(this.directory) ? Environment.CurrentDirectory : this.directory);
+            string path = Path.GetFullPath(Path.Combine(basePath, filePath));
+            if (!path.StartsWith(basePath, StringComparison.InvariantCultureIgnoreCase))
+            {
+                throw new InvalidDataException("Archive cannot contain files with absolute or traversal paths.");
+            }
+        }
+
+        #endregion
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression/ArchiveInfo.cs b/src/dtf/WixToolset.Dtf.Compression/ArchiveInfo.cs
new file mode 100644
index 00000000..b5da4ea8
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression/ArchiveInfo.cs
@@ -0,0 +1,781 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression
+{
+    using System;
+    using System.IO;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using System.Runtime.Serialization;
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// Abstract object representing a compressed archive on disk;
+    /// provides access to file-based operations on the archive.
+    /// </summary>
+    [Serializable]
+    public abstract class ArchiveInfo : FileSystemInfo
+    {
+        /// <summary>
+        /// Creates a new ArchiveInfo object representing an archive in a
+        /// specified path.
+        /// </summary>
+        /// <param name="path">The path to the archive. When creating an archive,
+        /// this file does not necessarily exist yet.</param>
+        protected ArchiveInfo(string path) : base()
+        {
+            if (path == null)
+            {
+                throw new ArgumentNullException("path");
+            }
+
+            // protected instance members inherited from FileSystemInfo:
+            this.OriginalPath = path;
+            this.FullPath = Path.GetFullPath(path);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the ArchiveInfo class with serialized data.
+        /// </summary>
+        /// <param name="info">The SerializationInfo that holds the serialized object
+        /// data about the exception being thrown.</param>
+        /// <param name="context">The StreamingContext that contains contextual
+        /// information about the source or destination.</param>
+        protected ArchiveInfo(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+
+        /// <summary>
+        /// Gets the directory that contains the archive.
+        /// </summary>
+        /// <value>A DirectoryInfo object representing the parent directory of the
+        /// archive.</value>
+        public DirectoryInfo Directory
+        {
+            get
+            {
+                return new DirectoryInfo(Path.GetDirectoryName(this.FullName));
+            }
+        }
+
+        /// <summary>
+        /// Gets the full path of the directory that contains the archive.
+        /// </summary>
+        /// <value>The full path of the directory that contains the archive.</value>
+        public string DirectoryName
+        {
+            get
+            {
+                return Path.GetDirectoryName(this.FullName);
+            }
+        }
+
+        /// <summary>
+        /// Gets the size of the archive.
+        /// </summary>
+        /// <value>The size of the archive in bytes.</value>
+        public long Length
+        {
+            get
+            {
+                return new FileInfo(this.FullName).Length;
+            }
+        }
+
+        /// <summary>
+        /// Gets the file name of the archive.
+        /// </summary>
+        /// <value>The file name of the archive, not including any path.</value>
+        public override string Name
+        {
+            get
+            {
+                return Path.GetFileName(this.FullName);
+            }
+        }
+
+        /// <summary>
+        /// Checks if the archive exists.
+        /// </summary>
+        /// <value>True if the archive exists; else false.</value>
+        public override bool Exists
+        {
+            get
+            {
+                return File.Exists(this.FullName);
+            }
+        }
+
+        /// <summary>
+        /// Gets the full path of the archive.
+        /// </summary>
+        /// <returns>The full path of the archive.</returns>
+        public override string ToString()
+        {
+            return this.FullName;
+        }
+
+        /// <summary>
+        /// Deletes the archive.
+        /// </summary>
+        public override void Delete()
+        {
+            File.Delete(this.FullName);
+        }
+
+        /// <summary>
+        /// Copies an existing archive to another location.
+        /// </summary>
+        /// <param name="destFileName">The destination file path.</param>
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "dest")]
+        public void CopyTo(string destFileName)
+        {
+            File.Copy(this.FullName, destFileName);
+        }
+
+        /// <summary>
+        /// Copies an existing archive to another location, optionally
+        /// overwriting the destination file.
+        /// </summary>
+        /// <param name="destFileName">The destination file path.</param>
+        /// <param name="overwrite">If true, the destination file will be
+        /// overwritten if it exists.</param>
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "dest")]
+        public void CopyTo(string destFileName, bool overwrite)
+        {
+            File.Copy(this.FullName, destFileName, overwrite);
+        }
+        
+        /// <summary>
+        /// Moves an existing archive to another location.
+        /// </summary>
+        /// <param name="destFileName">The destination file path.</param>
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "dest")]
+        public void MoveTo(string destFileName)
+        {
+            File.Move(this.FullName, destFileName);
+            this.FullPath = Path.GetFullPath(destFileName);
+        }
+
+        /// <summary>
+        /// Checks if the archive contains a valid archive header.
+        /// </summary>
+        /// <returns>True if the file is a valid archive; false otherwise.</returns>
+        public bool IsValid()
+        {
+            using (Stream stream = File.OpenRead(this.FullName))
+            {
+                using (CompressionEngine compressionEngine = this.CreateCompressionEngine())
+                {
+                    return compressionEngine.FindArchiveOffset(stream) >= 0;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets information about the files contained in the archive.
+        /// </summary>
+        /// <returns>A list of <see cref="ArchiveFileInfo"/> objects, each
+        /// containing information about a file in the archive.</returns>
+        public IList<ArchiveFileInfo> GetFiles()
+        {
+            return this.InternalGetFiles((Predicate<string>) null);
+        }
+
+        /// <summary>
+        /// Gets information about the certain files contained in the archive file.
+        /// </summary>
+        /// <param name="searchPattern">The search string, such as
+        /// &quot;*.txt&quot;.</param>
+        /// <returns>A list of <see cref="ArchiveFileInfo"/> objects, each containing
+        /// information about a file in the archive.</returns>
+        public IList<ArchiveFileInfo> GetFiles(string searchPattern)
+        {
+            if (searchPattern == null)
+            {
+                throw new ArgumentNullException("searchPattern");
+            }
+
+            string regexPattern = String.Format(
+                CultureInfo.InvariantCulture,
+                "^{0}$",
+                Regex.Escape(searchPattern).Replace("\\*", ".*").Replace("\\?", "."));
+            Regex regex = new Regex(
+                    regexPattern,
+                    RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
+
+            return this.InternalGetFiles(
+                delegate(string match)
+                {
+                    return regex.IsMatch(match);
+                });
+        }
+
+        /// <summary>
+        /// Extracts all files from an archive to a destination directory.
+        /// </summary>
+        /// <param name="destDirectory">Directory where the files are to be
+        /// extracted.</param>
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "dest")]
+        public void Unpack(string destDirectory)
+        {
+            this.Unpack(destDirectory, null);
+        }
+
+        /// <summary>
+        /// Extracts all files from an archive to a destination directory,
+        /// optionally extracting only newer files.
+        /// </summary>
+        /// <param name="destDirectory">Directory where the files are to be
+        /// extracted.</param>
+        /// <param name="progressHandler">Handler for receiving progress
+        /// information; this may be null if progress is not desired.</param>
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "dest")]
+        public void Unpack(
+            string destDirectory,
+            EventHandler<ArchiveProgressEventArgs> progressHandler)
+        {
+            using (CompressionEngine compressionEngine = this.CreateCompressionEngine())
+            {
+                compressionEngine.Progress += progressHandler;
+                ArchiveFileStreamContext streamContext =
+                    new ArchiveFileStreamContext(this.FullName, destDirectory, null);
+                streamContext.EnableOffsetOpen = true;
+                compressionEngine.Unpack(streamContext, null);
+            }
+        }
+
+        /// <summary>
+        /// Extracts a single file from the archive.
+        /// </summary>
+        /// <param name="fileName">The name of the file in the archive. Also
+        /// includes the internal path of the file, if any. File name matching
+        /// is case-insensitive.</param>
+        /// <param name="destFileName">The path where the file is to be
+        /// extracted on disk.</param>
+        /// <remarks>If <paramref name="destFileName"/> already exists,
+        /// it will be overwritten.</remarks>
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "dest")]
+        public void UnpackFile(string fileName, string destFileName)
+        {
+            if (fileName == null)
+            {
+                throw new ArgumentNullException("fileName");
+            }
+
+            if (destFileName == null)
+            {
+                throw new ArgumentNullException("destFileName");
+            }
+
+            this.UnpackFiles(
+                new string[] { fileName },
+                null,
+                new string[] { destFileName });
+        }
+
+        /// <summary>
+        /// Extracts multiple files from the archive.
+        /// </summary>
+        /// <param name="fileNames">The names of the files in the archive.
+        /// Each name includes the internal path of the file, if any. File name
+        /// matching is case-insensitive.</param>
+        /// <param name="destDirectory">This parameter may be null, but if
+        /// specified it is the root directory for any relative paths in
+        /// <paramref name="destFileNames"/>.</param>
+        /// <param name="destFileNames">The paths where the files are to be
+        /// extracted on disk. If this parameter is null, the files will be
+        /// extracted with the names from the archive.</param>
+        /// <remarks>
+        /// If any extracted files already exist on disk, they will be overwritten.
+        /// <p>The <paramref name="destDirectory"/> and
+        /// <paramref name="destFileNames"/> parameters cannot both be null.</p>
+        /// </remarks>
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "dest")]
+        public void UnpackFiles(
+            IList<string> fileNames,
+            string destDirectory,
+            IList<string> destFileNames)
+        {
+            this.UnpackFiles(fileNames, destDirectory, destFileNames, null);
+        }
+
+        /// <summary>
+        /// Extracts multiple files from the archive, optionally extracting
+        /// only newer files.
+        /// </summary>
+        /// <param name="fileNames">The names of the files in the archive.
+        /// Each name includes the internal path of the file, if any. File name
+        /// matching is case-insensitive.</param>
+        /// <param name="destDirectory">This parameter may be null, but if
+        /// specified it is the root directory for any relative paths in
+        /// <paramref name="destFileNames"/>.</param>
+        /// <param name="destFileNames">The paths where the files are to be
+        /// extracted on disk. If this parameter is null, the files will be
+        /// extracted with the names from the archive.</param>
+        /// <param name="progressHandler">Handler for receiving progress information;
+        /// this may be null if progress is not desired.</param>
+        /// <remarks>
+        /// If any extracted files already exist on disk, they will be overwritten.
+        /// <p>The <paramref name="destDirectory"/> and
+        /// <paramref name="destFileNames"/> parameters cannot both be null.</p>
+        /// </remarks>
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "dest")]
+        public void UnpackFiles(
+            IList<string> fileNames,
+            string destDirectory,
+            IList<string> destFileNames,
+            EventHandler<ArchiveProgressEventArgs> progressHandler)
+        {
+            if (fileNames == null)
+            {
+                throw new ArgumentNullException("fileNames");
+            }
+
+            if (destFileNames == null)
+            {
+                if (destDirectory == null)
+                {
+                    throw new ArgumentNullException("destFileNames");
+                }
+
+                destFileNames = fileNames;
+            }
+
+            if (destFileNames.Count != fileNames.Count)
+            {
+                throw new ArgumentOutOfRangeException("destFileNames");
+            }
+
+            IDictionary<string, string> files =
+                ArchiveInfo.CreateStringDictionary(fileNames, destFileNames);
+            this.UnpackFileSet(files, destDirectory, progressHandler);
+        }
+
+        /// <summary>
+        /// Extracts multiple files from the archive.
+        /// </summary>
+        /// <param name="fileNames">A mapping from internal file paths to
+        /// external file paths. Case-senstivity when matching internal paths
+        /// depends on the IDictionary implementation.</param>
+        /// <param name="destDirectory">This parameter may be null, but if
+        /// specified it is the root directory for any relative external paths
+        /// in <paramref name="fileNames"/>.</param>
+        /// <remarks>
+        /// If any extracted files already exist on disk, they will be overwritten.
+        /// </remarks>
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "dest")]
+        public void UnpackFileSet(
+            IDictionary<string, string> fileNames,
+            string destDirectory)
+        {
+            this.UnpackFileSet(fileNames, destDirectory, null);
+        }
+
+        /// <summary>
+        /// Extracts multiple files from the archive.
+        /// </summary>
+        /// <param name="fileNames">A mapping from internal file paths to
+        /// external file paths. Case-senstivity when matching internal
+        /// paths depends on the IDictionary implementation.</param>
+        /// <param name="destDirectory">This parameter may be null, but if
+        /// specified it is the root directory for any relative external
+        /// paths in <paramref name="fileNames"/>.</param>
+        /// <param name="progressHandler">Handler for receiving progress
+        /// information; this may be null if progress is not desired.</param>
+        /// <remarks>
+        /// If any extracted files already exist on disk, they will be overwritten.
+        /// </remarks>
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "dest")]
+        public void UnpackFileSet(
+            IDictionary<string, string> fileNames,
+            string destDirectory,
+            EventHandler<ArchiveProgressEventArgs> progressHandler)
+        {
+            if (fileNames == null)
+            {
+                throw new ArgumentNullException("fileNames");
+            }
+
+            using (CompressionEngine compressionEngine = this.CreateCompressionEngine())
+            {
+                compressionEngine.Progress += progressHandler;
+                ArchiveFileStreamContext streamContext =
+                    new ArchiveFileStreamContext(this.FullName, destDirectory, fileNames);
+                streamContext.EnableOffsetOpen = true;
+                compressionEngine.Unpack(
+                    streamContext,
+                    delegate(string match)
+                    {
+                        return fileNames.ContainsKey(match);
+                    });
+            }
+        }
+
+        /// <summary>
+        /// Opens a file inside the archive for reading without actually
+        /// extracting the file to disk.
+        /// </summary>
+        /// <param name="fileName">The name of the file in the archive. Also
+        /// includes the internal path of the file, if any. File name matching
+        /// is case-insensitive.</param>
+        /// <returns>
+        /// A stream for reading directly from the packed file. Like any stream
+        /// this should be closed/disposed as soon as it is no longer needed.
+        /// </returns>
+        public Stream OpenRead(string fileName)
+        {
+            Stream archiveStream = File.OpenRead(this.FullName);
+            CompressionEngine compressionEngine = this.CreateCompressionEngine();
+            Stream fileStream = compressionEngine.Unpack(archiveStream, fileName);
+
+            // Attach the archiveStream and compressionEngine to the
+            // fileStream so they get disposed when the fileStream is disposed.
+            return new CargoStream(fileStream, archiveStream, compressionEngine);
+        }
+
+        /// <summary>
+        /// Opens a file inside the archive for reading text with UTF-8 encoding
+        /// without actually extracting the file to disk.
+        /// </summary>
+        /// <param name="fileName">The name of the file in the archive. Also
+        /// includes the internal path of the file, if any. File name matching
+        /// is case-insensitive.</param>
+        /// <returns>
+        /// A reader for reading text directly from the packed file. Like any reader
+        /// this should be closed/disposed as soon as it is no longer needed.
+        /// </returns>
+        /// <remarks>
+        /// To open an archived text file with different encoding, use the
+        /// <see cref="OpenRead" /> method and pass the returned stream to one of
+        /// the <see cref="StreamReader" /> constructor overloads.
+        /// </remarks>
+        public StreamReader OpenText(string fileName)
+        {
+            return new StreamReader(this.OpenRead(fileName));
+        }
+
+        /// <summary>
+        /// Compresses all files in a directory into the archive.
+        /// Does not include subdirectories.
+        /// </summary>
+        /// <param name="sourceDirectory">The directory containing the
+        /// files to be included.</param>
+        /// <remarks>
+        /// Uses maximum compression level.
+        /// </remarks>
+        public void Pack(string sourceDirectory)
+        {
+            this.Pack(sourceDirectory, false, CompressionLevel.Max, null);
+        }
+
+        /// <summary>
+        /// Compresses all files in a directory into the archive, optionally
+        /// including subdirectories.
+        /// </summary>
+        /// <param name="sourceDirectory">This is the root directory
+        /// for to pack all files.</param>
+        /// <param name="includeSubdirectories">If true, recursively include
+        /// files in subdirectories.</param>
+        /// <param name="compLevel">The compression level used when creating
+        /// the archive.</param>
+        /// <param name="progressHandler">Handler for receiving progress information;
+        /// this may be null if progress is not desired.</param>
+        /// <remarks>
+        /// The files are stored in the archive using their relative file paths in
+        /// the directory tree, if supported by the archive file format.
+        /// </remarks>
+        public void Pack(
+            string sourceDirectory,
+            bool includeSubdirectories,
+            CompressionLevel compLevel,
+            EventHandler<ArchiveProgressEventArgs> progressHandler)
+        {
+            IList<string> files = this.GetRelativeFilePathsInDirectoryTree(
+                sourceDirectory, includeSubdirectories);
+            this.PackFiles(sourceDirectory, files, files, compLevel, progressHandler);
+        }
+
+        /// <summary>
+        /// Compresses files into the archive, specifying the names used to
+        /// store the files in the archive.
+        /// </summary>
+        /// <param name="sourceDirectory">This parameter may be null, but
+        /// if specified it is the root directory
+        /// for any relative paths in <paramref name="sourceFileNames"/>.</param>
+        /// <param name="sourceFileNames">The list of files to be included in
+        /// the archive.</param>
+        /// <param name="fileNames">The names of the files as they are stored
+        /// in the archive. Each name
+        /// includes the internal path of the file, if any. This parameter may
+        /// be null, in which case the files are stored in the archive with their
+        /// source file names and no path information.</param>
+        /// <remarks>
+        /// Uses maximum compression level.
+        /// <p>Duplicate items in the <paramref name="fileNames"/> array will cause
+        /// an <see cref="ArchiveException"/>.</p>
+        /// </remarks>
+        public void PackFiles(
+            string sourceDirectory,
+            IList<string> sourceFileNames,
+            IList<string> fileNames)
+        {
+            this.PackFiles(
+                sourceDirectory,
+                sourceFileNames,
+                fileNames,
+                CompressionLevel.Max,
+                null);
+        }
+
+        /// <summary>
+        /// Compresses files into the archive, specifying the names used to
+        /// store the files in the archive.
+        /// </summary>
+        /// <param name="sourceDirectory">This parameter may be null, but if
+        /// specified it is the root directory
+        /// for any relative paths in <paramref name="sourceFileNames"/>.</param>
+        /// <param name="sourceFileNames">The list of files to be included in
+        /// the archive.</param>
+        /// <param name="fileNames">The names of the files as they are stored in
+        /// the archive. Each name includes the internal path of the file, if any.
+        /// This parameter may be null, in which case the files are stored in the
+        /// archive with their source file names and no path information.</param>
+        /// <param name="compLevel">The compression level used when creating the
+        /// archive.</param>
+        /// <param name="progressHandler">Handler for receiving progress information;
+        /// this may be null if progress is not desired.</param>
+        /// <remarks>
+        /// Duplicate items in the <paramref name="fileNames"/> array will cause
+        /// an <see cref="ArchiveException"/>.
+        /// </remarks>
+        public void PackFiles(
+            string sourceDirectory,
+            IList<string> sourceFileNames,
+            IList<string> fileNames,
+            CompressionLevel compLevel,
+            EventHandler<ArchiveProgressEventArgs> progressHandler)
+        {
+            if (sourceFileNames == null)
+            {
+                throw new ArgumentNullException("sourceFileNames");
+            }
+
+            if (fileNames == null)
+            {
+                string[] fileNamesArray = new string[sourceFileNames.Count];
+                for (int i = 0; i < sourceFileNames.Count; i++)
+                {
+                    fileNamesArray[i] = Path.GetFileName(sourceFileNames[i]);
+                }
+
+                fileNames = fileNamesArray;
+            }
+            else if (fileNames.Count != sourceFileNames.Count)
+            {
+                throw new ArgumentOutOfRangeException("fileNames");
+            }
+
+            using (CompressionEngine compressionEngine = this.CreateCompressionEngine())
+            {
+                compressionEngine.Progress += progressHandler;
+                IDictionary<string, string> contextFiles =
+                    ArchiveInfo.CreateStringDictionary(fileNames, sourceFileNames);
+                ArchiveFileStreamContext streamContext = new ArchiveFileStreamContext(
+                        this.FullName, sourceDirectory, contextFiles);
+                streamContext.EnableOffsetOpen = true;
+                compressionEngine.CompressionLevel = compLevel;
+                compressionEngine.Pack(streamContext, fileNames);
+            }
+        }
+
+        /// <summary>
+        /// Compresses files into the archive, specifying the names used
+        /// to store the files in the archive.
+        /// </summary>
+        /// <param name="sourceDirectory">This parameter may be null, but if
+        /// specified it is the root directory
+        /// for any relative paths in <paramref name="fileNames"/>.</param>
+        /// <param name="fileNames">A mapping from internal file paths to
+        /// external file paths.</param>
+        /// <remarks>
+        /// Uses maximum compression level.
+        /// </remarks>
+        public void PackFileSet(
+            string sourceDirectory,
+            IDictionary<string, string> fileNames)
+        {
+            this.PackFileSet(sourceDirectory, fileNames, CompressionLevel.Max, null);
+        }
+
+        /// <summary>
+        /// Compresses files into the archive, specifying the names used to
+        /// store the files in the archive.
+        /// </summary>
+        /// <param name="sourceDirectory">This parameter may be null, but if
+        /// specified it is the root directory
+        /// for any relative paths in <paramref name="fileNames"/>.</param>
+        /// <param name="fileNames">A mapping from internal file paths to
+        /// external file paths.</param>
+        /// <param name="compLevel">The compression level used when creating
+        /// the archive.</param>
+        /// <param name="progressHandler">Handler for receiving progress information;
+        /// this may be null if progress is not desired.</param>
+        public void PackFileSet(
+            string sourceDirectory,
+            IDictionary<string, string> fileNames,
+            CompressionLevel compLevel,
+            EventHandler<ArchiveProgressEventArgs> progressHandler)
+        {
+            if (fileNames == null)
+            {
+                throw new ArgumentNullException("fileNames");
+            }
+
+            string[] fileNamesArray = new string[fileNames.Count];
+            fileNames.Keys.CopyTo(fileNamesArray, 0);
+
+            using (CompressionEngine compressionEngine = this.CreateCompressionEngine())
+            {
+                compressionEngine.Progress += progressHandler;
+                ArchiveFileStreamContext streamContext = new ArchiveFileStreamContext(
+                        this.FullName, sourceDirectory, fileNames);
+                streamContext.EnableOffsetOpen = true;
+                compressionEngine.CompressionLevel = compLevel;
+                compressionEngine.Pack(streamContext, fileNamesArray);
+            }
+        }
+
+        /// <summary>
+        /// Given a directory, gets the relative paths of all files in the
+        /// directory, optionally including all subdirectories.
+        /// </summary>
+        /// <param name="dir">The directory to search.</param>
+        /// <param name="includeSubdirectories">True to include subdirectories
+        /// in the search.</param>
+        /// <returns>A list of file paths relative to the directory.</returns>
+        internal IList<string> GetRelativeFilePathsInDirectoryTree(
+            string dir, bool includeSubdirectories)
+        {
+            IList<string> fileList = new List<string>();
+            this.RecursiveGetRelativeFilePathsInDirectoryTree(
+                dir, String.Empty, includeSubdirectories, fileList);
+            return fileList;
+        }
+
+        /// <summary>
+        /// Retrieves information about one file from this archive.
+        /// </summary>
+        /// <param name="path">Path of the file in the archive.</param>
+        /// <returns>File information, or null if the file was not found
+        /// in the archive.</returns>
+        internal ArchiveFileInfo GetFile(string path)
+        {
+            IList<ArchiveFileInfo> files = this.InternalGetFiles(
+                delegate(string match)
+                {
+                    return String.Compare(
+                        match, path, true, CultureInfo.InvariantCulture) == 0;
+                });
+            return (files != null && files.Count > 0 ? files[0] : null);
+        }
+
+        /// <summary>
+        /// Creates a compression engine that does the low-level work for
+        /// this object.
+        /// </summary>
+        /// <returns>A new compression engine instance that matches the specific
+        /// subclass of archive.</returns>
+        /// <remarks>
+        /// Each instance will be <see cref="CompressionEngine.Dispose()"/>d
+        /// immediately after use.
+        /// </remarks>
+        protected abstract CompressionEngine CreateCompressionEngine();
+
+        /// <summary>
+        /// Creates a case-insensitive dictionary mapping from one list of
+        /// strings to the other.
+        /// </summary>
+        /// <param name="keys">List of keys.</param>
+        /// <param name="values">List of values that are mapped 1-to-1 to
+        /// the keys.</param>
+        /// <returns>A filled dictionary of the strings.</returns>
+        private static IDictionary<string, string> CreateStringDictionary(
+            IList<string> keys, IList<string> values)
+        {
+            IDictionary<string, string> stringDict =
+                new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            for (int i = 0; i < keys.Count; i++)
+            {
+                stringDict.Add(keys[i], values[i]);
+            }
+
+            return stringDict;
+        }
+
+        /// <summary>
+        /// Recursive-descent helper function for
+        /// GetRelativeFilePathsInDirectoryTree.
+        /// </summary>
+        /// <param name="dir">The root directory of the search.</param>
+        /// <param name="relativeDir">The relative directory to be
+        /// processed now.</param>
+        /// <param name="includeSubdirectories">True to descend into
+        /// subdirectories.</param>
+        /// <param name="fileList">List of files found so far.</param>
+        private void RecursiveGetRelativeFilePathsInDirectoryTree(
+            string dir,
+            string relativeDir,
+            bool includeSubdirectories,
+            IList<string> fileList)
+        {
+            foreach (string file in System.IO.Directory.GetFiles(dir))
+            {
+                string fileName = Path.GetFileName(file);
+                fileList.Add(Path.Combine(relativeDir, fileName));
+            }
+
+            if (includeSubdirectories)
+            {
+                foreach (string subDir in System.IO.Directory.GetDirectories(dir))
+                {
+                    string subDirName = Path.GetFileName(subDir);
+                    this.RecursiveGetRelativeFilePathsInDirectoryTree(
+                        Path.Combine(dir, subDirName),
+                        Path.Combine(relativeDir, subDirName),
+                        includeSubdirectories,
+                        fileList);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Uses a CompressionEngine to get ArchiveFileInfo objects from this
+        /// archive, and then associates them with this ArchiveInfo instance.
+        /// </summary>
+        /// <param name="fileFilter">Optional predicate that can determine
+        /// which files to process.</param>
+        /// <returns>A list of <see cref="ArchiveFileInfo"/> objects, each
+        /// containing information about a file in the archive.</returns>
+        private IList<ArchiveFileInfo> InternalGetFiles(Predicate<string> fileFilter)
+        {
+            using (CompressionEngine compressionEngine = this.CreateCompressionEngine())
+            {
+                ArchiveFileStreamContext streamContext =
+                    new ArchiveFileStreamContext(this.FullName, null, null);
+                streamContext.EnableOffsetOpen = true;
+                IList<ArchiveFileInfo> files =
+                    compressionEngine.GetFileInfo(streamContext, fileFilter);
+                for (int i = 0; i < files.Count; i++)
+                {
+                    files[i].Archive = this;
+                }
+
+                return files;
+            }
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression/ArchiveProgressEventArgs.cs b/src/dtf/WixToolset.Dtf.Compression/ArchiveProgressEventArgs.cs
new file mode 100644
index 00000000..5d96d714
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression/ArchiveProgressEventArgs.cs
@@ -0,0 +1,307 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression
+{
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+    /// <summary>
+    /// Contains the data reported in an archive progress event.
+    /// </summary>
+    public class ArchiveProgressEventArgs : EventArgs
+    {
+        private ArchiveProgressType progressType;
+
+        private string currentFileName;
+        private int currentFileNumber;
+        private int totalFiles;
+        private long currentFileBytesProcessed;
+        private long currentFileTotalBytes;
+
+        private string currentArchiveName;
+        private short currentArchiveNumber;
+        private short totalArchives;
+        private long currentArchiveBytesProcessed;
+        private long currentArchiveTotalBytes;
+
+        private long fileBytesProcessed;
+        private long totalFileBytes;
+
+        /// <summary>
+        /// Creates a new ArchiveProgressEventArgs object from specified event parameters.
+        /// </summary>
+        /// <param name="progressType">type of status message</param>
+        /// <param name="currentFileName">name of the file being processed</param>
+        /// <param name="currentFileNumber">number of the current file being processed</param>
+        /// <param name="totalFiles">total number of files to be processed</param>
+        /// <param name="currentFileBytesProcessed">number of bytes processed so far when compressing or extracting a file</param>
+        /// <param name="currentFileTotalBytes">total number of bytes in the current file</param>
+        /// <param name="currentArchiveName">name of the current Archive</param>
+        /// <param name="currentArchiveNumber">current Archive number, when processing a chained set of Archives</param>
+        /// <param name="totalArchives">total number of Archives in a chained set</param>
+        /// <param name="currentArchiveBytesProcessed">number of compressed bytes processed so far during an extraction</param>
+        /// <param name="currentArchiveTotalBytes">total number of compressed bytes to be processed during an extraction</param>
+        /// <param name="fileBytesProcessed">number of uncompressed file bytes processed so far</param>
+        /// <param name="totalFileBytes">total number of uncompressed file bytes to be processed</param>
+        public ArchiveProgressEventArgs(
+            ArchiveProgressType progressType,
+            string currentFileName,
+            int currentFileNumber,
+            int totalFiles,
+            long currentFileBytesProcessed,
+            long currentFileTotalBytes,
+            string currentArchiveName,
+            int currentArchiveNumber,
+            int totalArchives,
+            long currentArchiveBytesProcessed,
+            long currentArchiveTotalBytes,
+            long fileBytesProcessed,
+            long totalFileBytes)
+        {
+            this.progressType = progressType;
+            this.currentFileName = currentFileName;
+            this.currentFileNumber = currentFileNumber;
+            this.totalFiles = totalFiles;
+            this.currentFileBytesProcessed = currentFileBytesProcessed;
+            this.currentFileTotalBytes = currentFileTotalBytes;
+            this.currentArchiveName = currentArchiveName;
+            this.currentArchiveNumber = (short) currentArchiveNumber;
+            this.totalArchives = (short) totalArchives;
+            this.currentArchiveBytesProcessed = currentArchiveBytesProcessed;
+            this.currentArchiveTotalBytes = currentArchiveTotalBytes;
+            this.fileBytesProcessed = fileBytesProcessed;
+            this.totalFileBytes = totalFileBytes;
+        }
+
+        /// <summary>
+        /// Gets the type of status message.
+        /// </summary>
+        /// <value>A <see cref="ArchiveProgressType"/> value indicating what type of progress event occurred.</value>
+        /// <remarks>
+        /// The handler may choose to ignore some types of progress events.
+        /// For example, if the handler will only list each file as it is
+        /// compressed/extracted, it can ignore events that
+        /// are not of type <see cref="ArchiveProgressType.FinishFile"/>.
+        /// </remarks>
+        public ArchiveProgressType ProgressType
+        {
+            get
+            {
+                return this.progressType;
+            }
+        }
+
+        /// <summary>
+        /// Gets the name of the file being processed. (The name of the file within the Archive; not the external
+        /// file path.) Also includes the internal path of the file, if any.  Valid for
+        /// <see cref="ArchiveProgressType.StartFile"/>, <see cref="ArchiveProgressType.PartialFile"/>,
+        /// and <see cref="ArchiveProgressType.FinishFile"/> messages.
+        /// </summary>
+        /// <value>The name of the file currently being processed, or null if processing
+        /// is currently at the stream or archive level.</value>
+        public string CurrentFileName
+        {
+            get
+            {
+                return this.currentFileName;
+            }
+        }
+
+        /// <summary>
+        /// Gets the number of the current file being processed. The first file is number 0, and the last file
+        /// is <see cref="TotalFiles"/>-1. Valid for <see cref="ArchiveProgressType.StartFile"/>,
+        /// <see cref="ArchiveProgressType.PartialFile"/>, and <see cref="ArchiveProgressType.FinishFile"/> messages.
+        /// </summary>
+        /// <value>The number of the file currently being processed, or the most recent
+        /// file processed if processing is currently at the stream or archive level.</value>
+        public int CurrentFileNumber
+        {
+            get
+            {
+                return this.currentFileNumber;
+            }
+        }
+
+        /// <summary>
+        /// Gets the total number of files to be processed.  Valid for all message types.
+        /// </summary>
+        /// <value>The total number of files to be processed that are known so far.</value>
+        public int TotalFiles
+        {
+            get
+            {
+                return this.totalFiles;
+            }
+        }
+
+        /// <summary>
+        /// Gets the number of bytes processed so far when compressing or extracting a file.  Valid for
+        /// <see cref="ArchiveProgressType.StartFile"/>, <see cref="ArchiveProgressType.PartialFile"/>,
+        /// and <see cref="ArchiveProgressType.FinishFile"/> messages.
+        /// </summary>
+        /// <value>The number of uncompressed bytes processed so far for the current file,
+        /// or 0 if processing is currently at the stream or archive level.</value>
+        public long CurrentFileBytesProcessed
+        {
+            get
+            {
+                return this.currentFileBytesProcessed;
+            }
+        }
+
+        /// <summary>
+        /// Gets the total number of bytes in the current file.  Valid for <see cref="ArchiveProgressType.StartFile"/>,
+        /// <see cref="ArchiveProgressType.PartialFile"/>, and <see cref="ArchiveProgressType.FinishFile"/> messages.
+        /// </summary>
+        /// <value>The uncompressed size of the current file being processed,
+        /// or 0 if processing is currently at the stream or archive level.</value>
+        public long CurrentFileTotalBytes
+        {
+            get
+            {
+                return this.currentFileTotalBytes;
+            }
+        }
+
+        /// <summary>
+        /// Gets the name of the current archive.  Not necessarily the name of the archive on disk.
+        /// Valid for all message types.
+        /// </summary>
+        /// <value>The name of the current archive, or an empty string if no name was specified.</value>
+        public string CurrentArchiveName
+        {
+            get
+            {
+                return this.currentArchiveName;
+            }
+        }
+
+        /// <summary>
+        /// Gets the current archive number, when processing a chained set of archives. Valid for all message types.
+        /// </summary>
+        /// <value>The number of the current archive.</value>
+        /// <remarks>The first archive is number 0, and the last archive is
+        /// <see cref="TotalArchives"/>-1.</remarks>
+        public int CurrentArchiveNumber
+        {
+            get
+            {
+                return this.currentArchiveNumber;
+            }
+        }
+
+        /// <summary>
+        /// Gets the total number of known archives in a chained set. Valid for all message types.
+        /// </summary>
+        /// <value>The total number of known archives in a chained set.</value>
+        /// <remarks>
+        /// When using the compression option to auto-split into multiple archives based on data size,
+        /// this value will not be accurate until the end.
+        /// </remarks>
+        public int TotalArchives
+        {
+            get
+            {
+                return this.totalArchives;
+            }
+        }
+
+        /// <summary>
+        /// Gets the number of compressed bytes processed so far during extraction
+        /// of the current archive. Valid for all extraction messages.
+        /// </summary>
+        /// <value>The number of compressed bytes processed so far during extraction
+        /// of the current archive.</value>
+        public long CurrentArchiveBytesProcessed
+        {
+            get
+            {
+                return this.currentArchiveBytesProcessed;
+            }
+        }
+
+        /// <summary>
+        /// Gets the total number of compressed bytes to be processed during extraction
+        /// of the current archive. Valid for all extraction messages.
+        /// </summary>
+        /// <value>The total number of compressed bytes to be processed during extraction
+        /// of the current archive.</value>
+        public long CurrentArchiveTotalBytes
+        {
+            get
+            {
+                return this.currentArchiveTotalBytes;
+            }
+        }
+
+        /// <summary>
+        /// Gets the number of uncompressed bytes processed so far among all files. Valid for all message types.  
+        /// </summary>
+        /// <value>The number of uncompressed file bytes processed so far among all files.</value>
+        /// <remarks>
+        /// When compared to <see cref="TotalFileBytes"/>, this can be used as a measure of overall progress.
+        /// </remarks>
+        public long FileBytesProcessed
+        {
+            get
+            {
+                return this.fileBytesProcessed;
+            }
+        }
+
+        /// <summary>
+        /// Gets the total number of uncompressed file bytes to be processed.  Valid for all message types.
+        /// </summary>
+        /// <value>The total number of uncompressed bytes to be processed among all files.</value>
+        public long TotalFileBytes
+        {
+            get
+            {
+                return this.totalFileBytes;
+            }
+        }
+
+#if DEBUG
+
+    /// <summary>
+    /// Creates a string representation of the progress event.
+    /// </summary>
+    /// <returns>a listing of all event parameters and values</returns>
+    public override string ToString()
+    {
+        string formatString =
+            "{0}\n" +
+            "\t CurrentFileName              = {1}\n" +
+            "\t CurrentFileNumber            = {2}\n" +
+            "\t TotalFiles                   = {3}\n" +
+            "\t CurrentFileBytesProcessed    = {4}\n" +
+            "\t CurrentFileTotalBytes        = {5}\n" +
+            "\t CurrentArchiveName           = {6}\n" +
+            "\t CurrentArchiveNumber         = {7}\n" +
+            "\t TotalArchives                = {8}\n" +
+            "\t CurrentArchiveBytesProcessed = {9}\n" +
+            "\t CurrentArchiveTotalBytes     = {10}\n" +
+            "\t FileBytesProcessed           = {11}\n" +
+            "\t TotalFileBytes               = {12}\n";
+        return String.Format(
+            System.Globalization.CultureInfo.InvariantCulture,
+            formatString,
+            this.ProgressType,
+            this.CurrentFileName,
+            this.CurrentFileNumber,
+            this.TotalFiles,
+            this.CurrentFileBytesProcessed,
+            this.CurrentFileTotalBytes,
+            this.CurrentArchiveName,
+            this.CurrentArchiveNumber,
+            this.TotalArchives,
+            this.CurrentArchiveBytesProcessed,
+            this.CurrentArchiveTotalBytes,
+            this.FileBytesProcessed,
+            this.TotalFileBytes);
+    }
+
+#endif
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression/ArchiveProgressType.cs b/src/dtf/WixToolset.Dtf.Compression/ArchiveProgressType.cs
new file mode 100644
index 00000000..2307c28e
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression/ArchiveProgressType.cs
@@ -0,0 +1,69 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression
+{
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+    /// <summary>
+    /// The type of progress event.
+    /// </summary>
+    /// <remarks>
+    /// <p>PACKING EXAMPLE: The following sequence of events might be received when
+    /// extracting a simple archive file with 2 files.</p>
+    /// <list type="table">
+    /// <listheader><term>Message Type</term><description>Description</description></listheader>
+    /// <item><term>StartArchive</term> <description>Begin extracting archive</description></item>
+    /// <item><term>StartFile</term>    <description>Begin extracting first file</description></item>
+    /// <item><term>PartialFile</term>  <description>Extracting first file</description></item>
+    /// <item><term>PartialFile</term>  <description>Extracting first file</description></item>
+    /// <item><term>FinishFile</term>   <description>Finished extracting first file</description></item>
+    /// <item><term>StartFile</term>    <description>Begin extracting second file</description></item>
+    /// <item><term>PartialFile</term>  <description>Extracting second file</description></item>
+    /// <item><term>FinishFile</term>   <description>Finished extracting second file</description></item>
+    /// <item><term>FinishArchive</term><description>Finished extracting archive</description></item>
+    /// </list>
+    /// <p></p>
+    /// <p>UNPACKING EXAMPLE:  Packing 3 files into 2 archive chunks, where the second file is
+    /// continued to the second archive chunk.</p>
+    /// <list type="table">
+    /// <listheader><term>Message Type</term><description>Description</description></listheader>
+    /// <item><term>StartFile</term>     <description>Begin compressing first file</description></item>
+    /// <item><term>FinishFile</term>    <description>Finished compressing first file</description></item>
+    /// <item><term>StartFile</term>     <description>Begin compressing second file</description></item>
+    /// <item><term>PartialFile</term>   <description>Compressing second file</description></item>
+    /// <item><term>PartialFile</term>   <description>Compressing second file</description></item>
+    /// <item><term>FinishFile</term>    <description>Finished compressing second file</description></item>
+    /// <item><term>StartArchive</term>  <description>Begin writing first archive</description></item>
+    /// <item><term>PartialArchive</term><description>Writing first archive</description></item>
+    /// <item><term>FinishArchive</term> <description>Finished writing first archive</description></item>
+    /// <item><term>StartFile</term>     <description>Begin compressing third file</description></item>
+    /// <item><term>PartialFile</term>   <description>Compressing third file</description></item>
+    /// <item><term>FinishFile</term>    <description>Finished compressing third file</description></item>
+    /// <item><term>StartArchive</term>  <description>Begin writing second archive</description></item>
+    /// <item><term>PartialArchive</term><description>Writing second archive</description></item>
+    /// <item><term>FinishArchive</term> <description>Finished writing second archive</description></item>
+    /// </list>
+    /// </remarks>
+    public enum ArchiveProgressType : int
+    {
+        /// <summary>Status message before beginning the packing or unpacking an individual file.</summary>
+        StartFile,
+
+        /// <summary>Status message (possibly reported multiple times) during the process of packing or unpacking a file.</summary>
+        PartialFile,
+
+        /// <summary>Status message after completion of the packing or unpacking an individual file.</summary>
+        FinishFile,
+
+        /// <summary>Status message before beginning the packing or unpacking an archive.</summary>
+        StartArchive,
+
+        /// <summary>Status message (possibly reported multiple times) during the process of packing or unpacking an archiv.</summary>
+        PartialArchive,
+
+        /// <summary>Status message after completion of the packing or unpacking of an archive.</summary>
+        FinishArchive,
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression/BasicUnpackStreamContext.cs b/src/dtf/WixToolset.Dtf.Compression/BasicUnpackStreamContext.cs
new file mode 100644
index 00000000..94d13b9c
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression/BasicUnpackStreamContext.cs
@@ -0,0 +1,90 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression
+{
+    using System;
+    using System.IO;
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// Stream context used to extract a single file from an archive into a memory stream.
+    /// </summary>
+    [SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable")]
+    public class BasicUnpackStreamContext : IUnpackStreamContext
+    {
+        private Stream archiveStream;
+        private Stream fileStream;
+
+        /// <summary>
+        /// Creates a new BasicExtractStreamContext that reads from the specified archive stream.
+        /// </summary>
+        /// <param name="archiveStream">Archive stream to read from.</param>
+        public BasicUnpackStreamContext(Stream archiveStream)
+        {
+            this.archiveStream = archiveStream;
+        }
+
+        /// <summary>
+        /// Gets the stream for the extracted file, or null if no file was extracted.
+        /// </summary>
+        public Stream FileStream
+        {
+            get
+            {
+                return this.fileStream;
+            }
+        }
+
+        /// <summary>
+        /// Opens the archive stream for reading. Returns a DuplicateStream instance,
+        /// so the stream may be virtually opened multiple times.
+        /// </summary>
+        /// <param name="archiveNumber">The archive number to open (ignored; 0 is assumed).</param>
+        /// <param name="archiveName">The name of the archive being opened.</param>
+        /// <param name="compressionEngine">Instance of the compression engine doing the operations.</param>
+        /// <returns>A stream from which archive bytes are read.</returns>
+        public Stream OpenArchiveReadStream(int archiveNumber, string archiveName, CompressionEngine compressionEngine)
+        {
+            return new DuplicateStream(this.archiveStream);
+        }
+
+        /// <summary>
+        /// Does *not* close the stream. The archive stream should be managed by
+        /// the code that invokes the archive extraction.
+        /// </summary>
+        /// <param name="archiveNumber">The archive number of the stream to close.</param>
+        /// <param name="archiveName">The name of the archive being closed.</param>
+        /// <param name="stream">The stream being closed.</param>
+        public void CloseArchiveReadStream(int archiveNumber, string archiveName, Stream stream)
+        {
+            // Do nothing.
+        }
+
+        /// <summary>
+        /// Opens a stream for writing extracted file bytes. The returned stream is a MemoryStream
+        /// instance, so the file is extracted straight into memory.
+        /// </summary>
+        /// <param name="path">Path of the file within the archive.</param>
+        /// <param name="fileSize">The uncompressed size of the file to be extracted.</param>
+        /// <param name="lastWriteTime">The last write time of the file.</param>
+        /// <returns>A stream where extracted file bytes are to be written.</returns>
+        public Stream OpenFileWriteStream(string path, long fileSize, DateTime lastWriteTime)
+        {
+            this.fileStream = new MemoryStream(new byte[fileSize], 0, (int) fileSize, true, true);
+            return this.fileStream;
+        }
+
+        /// <summary>
+        /// Does *not* close the file stream. The file stream is saved in memory so it can
+        /// be read later.
+        /// </summary>
+        /// <param name="path">Path of the file within the archive.</param>
+        /// <param name="stream">The file stream to be closed.</param>
+        /// <param name="attributes">The attributes of the extracted file.</param>
+        /// <param name="lastWriteTime">The last write time of the file.</param>
+        public void CloseFileWriteStream(string path, Stream stream, FileAttributes attributes, DateTime lastWriteTime)
+        {
+            // Do nothing.
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression/CargoStream.cs b/src/dtf/WixToolset.Dtf.Compression/CargoStream.cs
new file mode 100644
index 00000000..78798a35
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression/CargoStream.cs
@@ -0,0 +1,192 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+
+    /// <summary>
+    /// Wraps a source stream and carries additional items that are disposed when the stream is closed.
+    /// </summary>
+    public class CargoStream : Stream
+    {
+        private Stream source;
+        private List<IDisposable> cargo;
+
+        /// <summary>
+        /// Creates a new a cargo stream.
+        /// </summary>
+        /// <param name="source">source of the stream</param>
+        /// <param name="cargo">List of additional items that are disposed when the stream is closed.
+        /// The order of the list is the order in which the items are disposed.</param>
+        public CargoStream(Stream source, params IDisposable[] cargo)
+        {
+            if (source == null)
+            {
+                throw new ArgumentNullException("source");
+            }
+
+            this.source = source;
+            this.cargo = new List<IDisposable>(cargo);
+        }
+
+        /// <summary>
+        /// Gets the source stream of the cargo stream.
+        /// </summary>
+        public Stream Source
+        {
+            get
+            {
+                return this.source;
+            }
+        }
+
+        /// <summary>
+        /// Gets the list of additional items that are disposed when the stream is closed.
+        /// The order of the list is the order in which the items are disposed. The contents can be modified any time.
+        /// </summary>
+        public IList<IDisposable> Cargo
+        {
+            get
+            {
+                return this.cargo;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the source stream supports reading.
+        /// </summary>
+        /// <value>true if the stream supports reading; otherwise, false.</value>
+        public override bool CanRead
+        {
+            get
+            {
+                return this.source.CanRead;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the source stream supports writing.
+        /// </summary>
+        /// <value>true if the stream supports writing; otherwise, false.</value>
+        public override bool CanWrite
+        {
+            get
+            {
+                return this.source.CanWrite;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the source stream supports seeking.
+        /// </summary>
+        /// <value>true if the stream supports seeking; otherwise, false.</value>
+        public override bool CanSeek
+        {
+            get
+            {
+                return this.source.CanSeek;
+            }
+        }
+
+        /// <summary>
+        /// Gets the length of the source stream.
+        /// </summary>
+        public override long Length
+        {
+            get
+            {
+                return this.source.Length;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the position of the source stream.
+        /// </summary>
+        public override long Position
+        {
+            get
+            {
+                return this.source.Position;
+            }
+
+            set
+            {
+                this.source.Position = value;
+            }
+        }
+
+        /// <summary>
+        /// Flushes the source stream.
+        /// </summary>
+        public override void Flush()
+        {
+            this.source.Flush();
+        }
+
+        /// <summary>
+        /// Sets the length of the source stream.
+        /// </summary>
+        /// <param name="value">The desired length of the stream in bytes.</param>
+        public override void SetLength(long value)
+        {
+            this.source.SetLength(value);
+        }
+
+        /// <summary>
+        /// Closes the source stream and also closes the additional objects that are carried.
+        /// </summary>
+        public override void Close()
+        {
+            this.source.Close();
+
+            foreach (IDisposable cargoObject in this.cargo)
+            {
+                cargoObject.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Reads from the source stream.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. When this method returns, the buffer
+        /// contains the specified byte array with the values between offset and
+        /// (offset + count - 1) replaced by the bytes read from the source.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which to begin
+        /// storing the data read from the stream.</param>
+        /// <param name="count">The maximum number of bytes to be read from the stream.</param>
+        /// <returns>The total number of bytes read into the buffer. This can be less
+        /// than the number of bytes requested if that many bytes are not currently available,
+        /// or zero (0) if the end of the stream has been reached.</returns>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            return this.source.Read(buffer, offset, count);
+        }
+
+        /// <summary>
+        /// Writes to the source stream.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. This method copies count
+        /// bytes from buffer to the stream.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which
+        /// to begin copying bytes to the stream.</param>
+        /// <param name="count">The number of bytes to be written to the stream.</param>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            this.source.Write(buffer, offset, count);
+        }
+
+        /// <summary>
+        /// Changes the position of the source stream.
+        /// </summary>
+        /// <param name="offset">A byte offset relative to the origin parameter.</param>
+        /// <param name="origin">A value of type SeekOrigin indicating the reference
+        /// point used to obtain the new position.</param>
+        /// <returns>The new position within the stream.</returns>
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            return this.source.Seek(offset, origin);
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression/Compression.cd b/src/dtf/WixToolset.Dtf.Compression/Compression.cd
new file mode 100644
index 00000000..95012be0
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression/Compression.cd
@@ -0,0 +1,175 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ClassDiagram MajorVersion="1" MinorVersion="1">
+  <Comment CommentText="File-based classes">
+    <Position X="2.35" Y="1.442" Height="0.408" Width="0.783" />
+  </Comment>
+  <Comment CommentText="Stream-based classes">
+    <Position X="9.649" Y="1.317" Height="0.4" Width="0.996" />
+  </Comment>
+  <Class Name="WixToolset.Dtf.Compression.ArchiveException" Collapsed="true">
+    <Position X="3" Y="4.25" Width="2" />
+    <TypeIdentifier>
+      <HashCode>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode>
+      <FileName>ArchiveException.cs</FileName>
+    </TypeIdentifier>
+  </Class>
+  <Class Name="WixToolset.Dtf.Compression.ArchiveFileInfo">
+    <Position X="3" Y="0.5" Width="2" />
+    <Members>
+      <Method Name="ArchiveFileInfo" Hidden="true" />
+      <Field Name="archiveInfo" Hidden="true" />
+      <Field Name="archiveNumber" Hidden="true" />
+      <Field Name="attributes" Hidden="true" />
+      <Field Name="exists" Hidden="true" />
+      <Method Name="GetObjectData" Hidden="true" />
+      <Field Name="initialized" Hidden="true" />
+      <Field Name="lastWriteTime" Hidden="true" />
+      <Field Name="length" Hidden="true" />
+      <Field Name="name" Hidden="true" />
+      <Field Name="path" Hidden="true" />
+    </Members>
+    <TypeIdentifier>
+      <HashCode>AAAgAAAAIRJAAIMEAEACgARwAAEEEAAAASAAAAEAIAA=</HashCode>
+      <FileName>ArchiveFileInfo.cs</FileName>
+    </TypeIdentifier>
+  </Class>
+  <Class Name="WixToolset.Dtf.Compression.ArchiveInfo">
+    <Position X="0.5" Y="0.5" Width="2.25" />
+    <Members>
+      <Method Name="ArchiveInfo" Hidden="true" />
+      <Method Name="CreateStringDictionary" Hidden="true" />
+      <Method Name="GetFile" Hidden="true" />
+      <Method Name="GetRelativeFilePathsInDirectoryTree" Hidden="true" />
+      <Method Name="InternalGetFiles" Hidden="true" />
+      <Method Name="RecursiveGetRelativeFilePathsInDirectoryTree" Hidden="true" />
+    </Members>
+    <TypeIdentifier>
+      <HashCode>AAEAABAAIAAAAgQEAAgBAARAHAEJACAAAABEAAkAMAI=</HashCode>
+      <FileName>ArchiveInfo.cs</FileName>
+    </TypeIdentifier>
+  </Class>
+  <Class Name="WixToolset.Dtf.Compression.ArchiveFileStreamContext">
+    <Position X="12.75" Y="0.75" Width="2.25" />
+    <Members>
+      <Field Name="archiveFiles" Hidden="true" />
+      <Method Name="ArchiveFileStreamContext" Hidden="true" />
+      <Method Name="CloseArchiveReadStream" Hidden="true" />
+      <Method Name="CloseArchiveWriteStream" Hidden="true" />
+      <Method Name="CloseFileReadStream" Hidden="true" />
+      <Method Name="CloseFileWriteStream" Hidden="true" />
+      <Field Name="directory" Hidden="true" />
+      <Field Name="enableOffsetOpen" Hidden="true" />
+      <Field Name="extractOnlyNewerFiles" Hidden="true" />
+      <Field Name="files" Hidden="true" />
+      <Method Name="GetArchiveName" Hidden="true" />
+      <Method Name="GetOption" Hidden="true" />
+      <Method Name="OpenArchiveReadStream" Hidden="true" />
+      <Method Name="OpenArchiveWriteStream" Hidden="true" />
+      <Method Name="OpenFileReadStream" Hidden="true" />
+      <Method Name="OpenFileWriteStream" Hidden="true" />
+      <Method Name="TranslateFilePath" Hidden="true" />
+    </Members>
+    <TypeIdentifier>
+      <HashCode>AEQAABgAAACQAACACACAAgAQAAIgAAAAACAMgAAEAKA=</HashCode>
+      <FileName>ArchiveFileStreamContext.cs</FileName>
+    </TypeIdentifier>
+    <Lollipop Position="0.2" />
+  </Class>
+  <Class Name="WixToolset.Dtf.Compression.ArchiveProgressEventArgs">
+    <Position X="5.25" Y="0.5" Width="2.25" />
+    <Members>
+      <Method Name="ArchiveProgressEventArgs" Hidden="true" />
+      <Field Name="currentArchiveBytesProcessed" Hidden="true" />
+      <Field Name="currentArchiveName" Hidden="true" />
+      <Field Name="currentArchiveNumber" Hidden="true" />
+      <Field Name="currentArchiveTotalBytes" Hidden="true" />
+      <Field Name="currentFileBytesProcessed" Hidden="true" />
+      <Field Name="currentFileName" Hidden="true" />
+      <Field Name="currentFileNumber" Hidden="true" />
+      <Field Name="currentFileTotalBytes" Hidden="true" />
+      <Field Name="fileBytesProcessed" Hidden="true" />
+      <Field Name="progressType" Hidden="true" />
+      <Field Name="totalArchives" Hidden="true" />
+      <Field Name="totalFileBytes" Hidden="true" />
+      <Field Name="totalFiles" Hidden="true" />
+    </Members>
+    <TypeIdentifier>
+      <HashCode>AAMCAQASACAAABBBAAASUAAAQBAAAMAAAAGQAAgBEAA=</HashCode>
+      <FileName>ArchiveProgressEventArgs.cs</FileName>
+    </TypeIdentifier>
+  </Class>
+  <Class Name="WixToolset.Dtf.Compression.BasicUnpackStreamContext">
+    <Position X="12.75" Y="3" Width="2.25" />
+    <Members>
+      <Field Name="archiveStream" Hidden="true" />
+      <Method Name="BasicUnpackStreamContext" Hidden="true" />
+      <Method Name="CloseArchiveReadStream" Hidden="true" />
+      <Method Name="CloseFileWriteStream" Hidden="true" />
+      <Field Name="fileStream" Hidden="true" />
+      <Method Name="OpenArchiveReadStream" Hidden="true" />
+      <Method Name="OpenFileWriteStream" Hidden="true" />
+    </Members>
+    <TypeIdentifier>
+      <HashCode>AAAAAAgAAACEAAAAAAAAAAAAAAAgAAAAIAAMAAAAAAA=</HashCode>
+      <FileName>BasicUnpackStreamContext.cs</FileName>
+    </TypeIdentifier>
+    <Lollipop Position="0.2" />
+  </Class>
+  <Class Name="WixToolset.Dtf.Compression.CompressionEngine">
+    <Position X="8" Y="0.5" Width="2.25" />
+    <Members>
+      <Method Name="~CompressionEngine" Hidden="true" />
+      <Method Name="CompressionEngine" Hidden="true" />
+      <Field Name="compressionLevel" Hidden="true" />
+      <Field Name="dontUseTempFiles" Hidden="true" />
+    </Members>
+    <TypeIdentifier>
+      <HashCode>AAAEAAAABCBAACRgAAAAAAQAAEAAAAAAQAEAAAiAAAI=</HashCode>
+      <FileName>CompressionEngine.cs</FileName>
+    </TypeIdentifier>
+    <Lollipop Position="0.2" />
+  </Class>
+  <Class Name="WixToolset.Dtf.Compression.DuplicateStream" Collapsed="true">
+    <Position X="10.5" Y="4.25" Width="2" />
+    <TypeIdentifier>
+      <HashCode>AAAAAEAAAgAAQAIgGAAAIABgAAAAAAAAAAAAAAGIACA=</HashCode>
+      <FileName>DuplicateStream.cs</FileName>
+    </TypeIdentifier>
+  </Class>
+  <Class Name="WixToolset.Dtf.Compression.OffsetStream" Collapsed="true">
+    <Position X="8" Y="4.25" Width="2" />
+    <TypeIdentifier>
+      <HashCode>AAAAAAAAAgAAQAIgGAAAAABgAAAAAEAgAAAAAAGIwCA=</HashCode>
+      <FileName>OffsetStream.cs</FileName>
+    </TypeIdentifier>
+  </Class>
+  <Interface Name="WixToolset.Dtf.Compression.IPackStreamContext">
+    <Position X="10.5" Y="0.5" Width="2" />
+    <TypeIdentifier>
+      <HashCode>AAAAAAAAAAAAAACAAACAAAAQAAAgAAAAACAIAAAAAAA=</HashCode>
+      <FileName>IPackStreamContext.cs</FileName>
+    </TypeIdentifier>
+  </Interface>
+  <Interface Name="WixToolset.Dtf.Compression.IUnpackStreamContext">
+    <Position X="10.5" Y="2.5" Width="2" />
+    <TypeIdentifier>
+      <HashCode>AAAAAAgAAACAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAA=</HashCode>
+      <FileName>IUnpackStreamContext.cs</FileName>
+    </TypeIdentifier>
+  </Interface>
+  <Enum Name="WixToolset.Dtf.Compression.ArchiveProgressType" Collapsed="true">
+    <Position X="5.25" Y="3.75" Width="2" />
+    <TypeIdentifier>
+      <HashCode>QAAAAAAAAAAAAIAAgAAAAAAAAAQAAAAACIAAAAAAAAA=</HashCode>
+      <FileName>ArchiveProgressType.cs</FileName>
+    </TypeIdentifier>
+  </Enum>
+  <Enum Name="WixToolset.Dtf.Compression.CompressionLevel" Collapsed="true">
+    <Position X="5.25" Y="4.5" Width="2" />
+    <TypeIdentifier>
+      <HashCode>AAAAAAAAABAAAAAAEAAAAAAAAAAIAAAAAAAAAAEAAAA=</HashCode>
+      <FileName>CompressionLevel.cs</FileName>
+    </TypeIdentifier>
+  </Enum>
+  <Font Name="Verdana" Size="8" />
+</ClassDiagram>
\ No newline at end of file
diff --git a/src/dtf/WixToolset.Dtf.Compression/CompressionEngine.cs b/src/dtf/WixToolset.Dtf.Compression/CompressionEngine.cs
new file mode 100644
index 00000000..7758ea98
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression/CompressionEngine.cs
@@ -0,0 +1,371 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression
+{
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Globalization;
+
+    /// <summary>
+    /// Base class for an engine capable of packing and unpacking a particular
+    /// compressed file format.
+    /// </summary>
+    public abstract class CompressionEngine : IDisposable
+    {
+        private CompressionLevel compressionLevel;
+        private bool dontUseTempFiles;
+
+        /// <summary>
+        /// Creates a new instance of the compression engine base class.
+        /// </summary>
+        protected CompressionEngine()
+        {
+            this.compressionLevel = CompressionLevel.Normal;
+        }
+
+        /// <summary>
+        /// Disposes the compression engine.
+        /// </summary>
+        ~CompressionEngine()
+        {
+            this.Dispose(false);
+        }
+
+        /// <summary>
+        /// Occurs when the compression engine reports progress in packing
+        /// or unpacking an archive.
+        /// </summary>
+        /// <seealso cref="ArchiveProgressType"/>
+        public event EventHandler<ArchiveProgressEventArgs> Progress;
+
+        /// <summary>
+        /// Gets or sets a flag indicating whether temporary files are created
+        /// and used during compression.
+        /// </summary>
+        /// <value>True if temporary files are used; false if compression is done
+        /// entirely in-memory.</value>
+        /// <remarks>The value of this property is true by default. Using temporary
+        /// files can greatly reduce the memory requirement of compression,
+        /// especially when compressing large archives. However, setting this property
+        /// to false may yield slightly better performance when creating small
+        /// archives. Or it may be necessary if the process does not have sufficient
+        /// privileges to create temporary files.</remarks>
+        public bool UseTempFiles
+        {
+            get
+            {
+                return !this.dontUseTempFiles;
+            }
+
+            set
+            {
+                this.dontUseTempFiles = !value;
+            }
+        }
+
+        /// <summary>
+        /// Compression level to use when compressing files.
+        /// </summary>
+        /// <value>A compression level ranging from minimum to maximum compression,
+        /// or no compression.</value>
+        public CompressionLevel CompressionLevel
+        {
+            get
+            {
+                return this.compressionLevel;
+            }
+
+            set
+            {
+                this.compressionLevel = value;
+            }
+        }
+
+        /// <summary>
+        /// Disposes of resources allocated by the compression engine.
+        /// </summary>
+        public void Dispose()
+        {
+            this.Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Creates an archive.
+        /// </summary>
+        /// <param name="streamContext">A context interface to handle opening
+        /// and closing of archive and file streams.</param>
+        /// <param name="files">The paths of the files in the archive
+        /// (not external file paths).</param>
+        /// <exception cref="ArchiveException">The archive could not be
+        /// created.</exception>
+        /// <remarks>
+        /// The stream context implementation may provide a mapping from the
+        /// file paths within the archive to the external file paths.
+        /// </remarks>
+        public void Pack(IPackStreamContext streamContext, IEnumerable<string> files)
+        {
+            if (files == null)
+            {
+                throw new ArgumentNullException("files");
+            }
+
+            this.Pack(streamContext, files, 0);
+        }
+
+        /// <summary>
+        /// Creates an archive or chain of archives.
+        /// </summary>
+        /// <param name="streamContext">A context interface to handle opening
+        /// and closing of archive and file streams.</param>
+        /// <param name="files">The paths of the files in the archive (not
+        /// external file paths).</param>
+        /// <param name="maxArchiveSize">The maximum number of bytes for one
+        /// archive before the contents are chained to the next archive, or zero
+        /// for unlimited archive size.</param>
+        /// <exception cref="ArchiveException">The archive could not be
+        /// created.</exception>
+        /// <remarks>
+        /// The stream context implementation may provide a mapping from the file
+        /// paths within the archive to the external file paths.
+        /// </remarks>
+        public abstract void Pack(
+            IPackStreamContext streamContext,
+            IEnumerable<string> files,
+            long maxArchiveSize);
+
+        /// <summary>
+        /// Checks whether a Stream begins with a header that indicates
+        /// it is a valid archive.
+        /// </summary>
+        /// <param name="stream">Stream for reading the archive file.</param>
+        /// <returns>True if the stream is a valid archive
+        /// (with no offset); false otherwise.</returns>
+        public abstract bool IsArchive(Stream stream);
+
+        /// <summary>
+        /// Gets the offset of an archive that is positioned 0 or more bytes
+        /// from the start of the Stream.
+        /// </summary>
+        /// <param name="stream">A stream for reading the archive.</param>
+        /// <returns>The offset in bytes of the archive,
+        /// or -1 if no archive is found in the Stream.</returns>
+        /// <remarks>The archive must begin on a 4-byte boundary.</remarks>
+        public virtual long FindArchiveOffset(Stream stream)
+        {
+            if (stream == null)
+            {
+                throw new ArgumentNullException("stream");
+            }
+
+            long sectionSize = 4;
+            long length = stream.Length;
+            for (long offset = 0; offset <= length - sectionSize; offset += sectionSize)
+            {
+                stream.Seek(offset, SeekOrigin.Begin);
+                if (this.IsArchive(stream))
+                {
+                    return offset;
+                }
+            }
+
+            return -1;
+        }
+
+        /// <summary>
+        /// Gets information about all files in an archive stream.
+        /// </summary>
+        /// <param name="stream">A stream for reading the archive.</param>
+        /// <returns>Information about all files in the archive stream.</returns>
+        /// <exception cref="ArchiveException">The stream is not a valid
+        /// archive.</exception>
+        public IList<ArchiveFileInfo> GetFileInfo(Stream stream)
+        {
+            return this.GetFileInfo(new BasicUnpackStreamContext(stream), null);
+        }
+
+        /// <summary>
+        /// Gets information about files in an archive or archive chain.
+        /// </summary>
+        /// <param name="streamContext">A context interface to handle opening
+        /// and closing of archive and file streams.</param>
+        /// <param name="fileFilter">A predicate that can determine
+        /// which files to process, optional.</param>
+        /// <returns>Information about files in the archive stream.</returns>
+        /// <exception cref="ArchiveException">The archive provided
+        /// by the stream context is not valid.</exception>
+        /// <remarks>
+        /// The <paramref name="fileFilter"/> predicate takes an internal file
+        /// path and returns true to include the file or false to exclude it.
+        /// </remarks>
+        public abstract IList<ArchiveFileInfo> GetFileInfo(
+            IUnpackStreamContext streamContext,
+            Predicate<string> fileFilter);
+
+        /// <summary>
+        /// Gets the list of files in an archive Stream.
+        /// </summary>
+        /// <param name="stream">A stream for reading the archive.</param>
+        /// <returns>A list of the paths of all files contained in the
+        /// archive.</returns>
+        /// <exception cref="ArchiveException">The stream is not a valid
+        /// archive.</exception>
+        public IList<string> GetFiles(Stream stream)
+        {
+            return this.GetFiles(new BasicUnpackStreamContext(stream), null);
+        }
+
+        /// <summary>
+        /// Gets the list of files in an archive or archive chain.
+        /// </summary>
+        /// <param name="streamContext">A context interface to handle opening
+        /// and closing of archive and file streams.</param>
+        /// <param name="fileFilter">A predicate that can determine
+        /// which files to process, optional.</param>
+        /// <returns>An array containing the names of all files contained in
+        /// the archive or archive chain.</returns>
+        /// <exception cref="ArchiveException">The archive provided
+        /// by the stream context is not valid.</exception>
+        /// <remarks>
+        /// The <paramref name="fileFilter"/> predicate takes an internal file
+        /// path and returns true to include the file or false to exclude it.
+        /// </remarks>
+        public IList<string> GetFiles(
+            IUnpackStreamContext streamContext,
+            Predicate<string> fileFilter)
+        {
+            if (streamContext == null)
+            {
+                throw new ArgumentNullException("streamContext");
+            }
+
+            IList<ArchiveFileInfo> files =
+                this.GetFileInfo(streamContext, fileFilter);
+            IList<string> fileNames = new List<string>(files.Count);
+            for (int i = 0; i < files.Count; i++)
+            {
+                fileNames.Add(files[i].Name);
+            }
+
+            return fileNames;
+        }
+
+        /// <summary>
+        /// Reads a single file from an archive stream.
+        /// </summary>
+        /// <param name="stream">A stream for reading the archive.</param>
+        /// <param name="path">The path of the file within the archive
+        /// (not the external file path).</param>
+        /// <returns>A stream for reading the extracted file, or null
+        /// if the file does not exist in the archive.</returns>
+        /// <exception cref="ArchiveException">The stream is not a valid
+        /// archive.</exception>
+        /// <remarks>The entire extracted file is cached in memory, so this
+        /// method requires enough free memory to hold the file.</remarks>
+        public Stream Unpack(Stream stream, string path)
+        {
+            if (stream == null)
+            {
+                throw new ArgumentNullException("stream");
+            }
+
+            if (path == null)
+            {
+                throw new ArgumentNullException("path");
+            }
+
+            BasicUnpackStreamContext streamContext =
+                new BasicUnpackStreamContext(stream);
+            this.Unpack(
+                streamContext,
+                delegate(string match)
+                {
+                    return String.Compare(
+                        match, path, true, CultureInfo.InvariantCulture) == 0;
+                });
+            
+            Stream extractStream = streamContext.FileStream;
+            if (extractStream != null)
+            {
+                extractStream.Position = 0;
+            }
+
+            return extractStream;
+        }
+
+        /// <summary>
+        /// Extracts files from an archive or archive chain.
+        /// </summary>
+        /// <param name="streamContext">A context interface to handle opening
+        /// and closing of archive and file streams.</param>
+        /// <param name="fileFilter">An optional predicate that can determine
+        /// which files to process.</param>
+        /// <exception cref="ArchiveException">The archive provided
+        /// by the stream context is not valid.</exception>
+        /// <remarks>
+        /// The <paramref name="fileFilter"/> predicate takes an internal file
+        /// path and returns true to include the file or false to exclude it.
+        /// </remarks>
+        public abstract void Unpack(
+            IUnpackStreamContext streamContext,
+            Predicate<string> fileFilter);
+
+        /// <summary>
+        /// Called by sublcasses to distribute a packing or unpacking progress
+        /// event to listeners.
+        /// </summary>
+        /// <param name="e">Event details.</param>
+        protected void OnProgress(ArchiveProgressEventArgs e)
+        {
+            if (this.Progress != null)
+            {
+                this.Progress(this, e);
+            }
+        }
+
+        /// <summary>
+        /// Disposes of resources allocated by the compression engine.
+        /// </summary>
+        /// <param name="disposing">If true, the method has been called
+        /// directly or indirectly by a user's code, so managed and unmanaged
+        /// resources will be disposed. If false, the method has been called by
+        /// the runtime from inside the finalizer, and only unmanaged resources
+        /// will be disposed.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+        }
+
+        /// <summary>
+        /// Compresion utility function for converting old-style
+        /// date and time values to a DateTime structure.
+        /// </summary>
+        public static void DosDateAndTimeToDateTime(
+            short dosDate, short dosTime, out DateTime dateTime)
+        {
+            if (dosDate == 0 && dosTime == 0)
+            {
+                dateTime = DateTime.MinValue;
+            }
+            else
+            {
+                long fileTime;
+                SafeNativeMethods.DosDateTimeToFileTime(dosDate, dosTime, out fileTime);
+                dateTime = DateTime.FromFileTimeUtc(fileTime);
+                dateTime = new DateTime(dateTime.Ticks, DateTimeKind.Local);
+            }
+        }
+
+        /// <summary>
+        /// Compresion utility function for converting a DateTime structure
+        /// to old-style date and time values.
+        /// </summary>
+        public static void DateTimeToDosDateAndTime(
+            DateTime dateTime, out short dosDate, out short dosTime)
+        {
+            dateTime = new DateTime(dateTime.Ticks, DateTimeKind.Utc);
+            long filetime = dateTime.ToFileTimeUtc();
+            SafeNativeMethods.FileTimeToDosDateTime(ref filetime, out dosDate, out dosTime);
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression/CompressionLevel.cs b/src/dtf/WixToolset.Dtf.Compression/CompressionLevel.cs
new file mode 100644
index 00000000..84ec8fc4
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression/CompressionLevel.cs
@@ -0,0 +1,31 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression
+{
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+    /// <summary>
+    /// Specifies the compression level ranging from minimum compresion to
+    /// maximum compression, or no compression at all.
+    /// </summary>
+    /// <remarks>
+    /// Although only four values are enumerated, any integral value between
+    /// <see cref="CompressionLevel.Min"/> and <see cref="CompressionLevel.Max"/> can also be used.
+    /// </remarks>
+    public enum CompressionLevel
+    {
+        /// <summary>Do not compress files, only store.</summary>
+        None = 0,
+
+        /// <summary>Minimum compression; fastest.</summary>
+        Min = 1,
+
+        /// <summary>A compromize between speed and compression efficiency.</summary>
+        Normal = 6,
+
+        /// <summary>Maximum compression; slowest.</summary>
+        Max = 10
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression/DuplicateStream.cs b/src/dtf/WixToolset.Dtf.Compression/DuplicateStream.cs
new file mode 100644
index 00000000..50e62e73
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression/DuplicateStream.cs
@@ -0,0 +1,212 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression
+{
+    using System;
+    using System.IO;
+
+    /// <summary>
+    /// Duplicates a source stream by maintaining a separate position.
+    /// </summary>
+    /// <remarks>
+    /// WARNING: duplicate streams are not thread-safe with respect to each other or the original stream.
+    /// If multiple threads use duplicate copies of the same stream, they must synchronize for any operations.
+    /// </remarks>
+    public class DuplicateStream : Stream
+    {
+        private Stream source;
+        private long position;
+
+        /// <summary>
+        /// Creates a new duplicate of a stream.
+        /// </summary>
+        /// <param name="source">source of the duplicate</param>
+        public DuplicateStream(Stream source)
+        {
+            if (source == null)
+            {
+                throw new ArgumentNullException("source");
+            }
+
+            this.source = DuplicateStream.OriginalStream(source);
+        }
+
+        /// <summary>
+        /// Gets the original stream that was used to create the duplicate.
+        /// </summary>
+        public Stream Source
+        {
+            get
+            {
+                return this.source;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the source stream supports reading.
+        /// </summary>
+        /// <value>true if the stream supports reading; otherwise, false.</value>
+        public override bool CanRead
+        {
+            get
+            {
+                return this.source.CanRead;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the source stream supports writing.
+        /// </summary>
+        /// <value>true if the stream supports writing; otherwise, false.</value>
+        public override bool CanWrite
+        {
+            get
+            {
+                return this.source.CanWrite;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the source stream supports seeking.
+        /// </summary>
+        /// <value>true if the stream supports seeking; otherwise, false.</value>
+        public override bool CanSeek
+        {
+            get
+            {
+                return this.source.CanSeek;
+            }
+        }
+
+        /// <summary>
+        /// Gets the length of the source stream.
+        /// </summary>
+        public override long Length
+        {
+            get
+            {
+                return this.source.Length;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the position of the current stream,
+        /// ignoring the position of the source stream.
+        /// </summary>
+        public override long Position
+        {
+            get
+            {
+                return this.position;
+            }
+
+            set
+            {
+                this.position = value;
+            }
+        }
+
+        /// <summary>
+        /// Retrieves the original stream from a possible duplicate stream.
+        /// </summary>
+        /// <param name="stream">Possible duplicate stream.</param>
+        /// <returns>If the stream is a DuplicateStream, returns
+        /// the duplicate's source; otherwise returns the same stream.</returns>
+        public static Stream OriginalStream(Stream stream)
+        {
+            DuplicateStream dupStream = stream as DuplicateStream;
+            return dupStream != null ? dupStream.Source : stream;
+        }
+
+        /// <summary>
+        /// Flushes the source stream.
+        /// </summary>
+        public override void Flush()
+        {
+            this.source.Flush();
+        }
+
+        /// <summary>
+        /// Sets the length of the source stream.
+        /// </summary>
+        /// <param name="value">The desired length of the stream in bytes.</param>
+        public override void SetLength(long value)
+        { 
+            this.source.SetLength(value);
+        }
+
+        /// <summary>
+        /// Closes the underlying stream, effectively closing ALL duplicates.
+        /// </summary>
+        public override void Close()
+        {
+            this.source.Close();
+        }
+
+        /// <summary>
+        /// Reads from the source stream while maintaining a separate position
+        /// and not impacting the source stream's position.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. When this method returns, the buffer
+        /// contains the specified byte array with the values between offset and
+        /// (offset + count - 1) replaced by the bytes read from the current source.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which to begin
+        /// storing the data read from the current stream.</param>
+        /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
+        /// <returns>The total number of bytes read into the buffer. This can be less
+        /// than the number of bytes requested if that many bytes are not currently available,
+        /// or zero (0) if the end of the stream has been reached.</returns>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            long saveSourcePosition = this.source.Position;
+            this.source.Position = this.position;
+            int read = this.source.Read(buffer, offset, count);
+            this.position = this.source.Position;
+            this.source.Position = saveSourcePosition;
+            return read;
+        }
+
+        /// <summary>
+        /// Writes to the source stream while maintaining a separate position
+        /// and not impacting the source stream's position.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. This method copies count
+        /// bytes from buffer to the current stream.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which
+        /// to begin copying bytes to the current stream.</param>
+        /// <param name="count">The number of bytes to be written to the
+        /// current stream.</param>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            long saveSourcePosition = this.source.Position;
+            this.source.Position = this.position;
+            this.source.Write(buffer, offset, count);
+            this.position = this.source.Position;
+            this.source.Position = saveSourcePosition;
+        }
+
+        /// <summary>
+        /// Changes the position of this stream without impacting the
+        /// source stream's position.
+        /// </summary>
+        /// <param name="offset">A byte offset relative to the origin parameter.</param>
+        /// <param name="origin">A value of type SeekOrigin indicating the reference
+        /// point used to obtain the new position.</param>
+        /// <returns>The new position within the current stream.</returns>
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            long originPosition = 0;
+            if (origin == SeekOrigin.Current)
+            {
+                originPosition = this.position;
+            }
+            else if (origin == SeekOrigin.End)
+            {
+                originPosition = this.Length;
+            }
+
+            this.position = originPosition + offset;
+            return this.position;
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression/IPackStreamContext.cs b/src/dtf/WixToolset.Dtf.Compression/IPackStreamContext.cs
new file mode 100644
index 00000000..19d77be5
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression/IPackStreamContext.cs
@@ -0,0 +1,117 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression
+{
+    using System;
+    using System.IO;
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// This interface provides the methods necessary for the
+    /// <see cref="CompressionEngine"/> to open and close streams for archives
+    /// and files. The implementor of this interface can use any kind of logic
+    /// to determine what kind of streams to open and where.
+    /// </summary>
+    public interface IPackStreamContext
+    {
+        /// <summary>
+        /// Gets the name of the archive with a specified number.
+        /// </summary>
+        /// <param name="archiveNumber">The 0-based index of the archive
+        /// within the chain.</param>
+        /// <returns>The name of the requested archive. May be an empty string
+        /// for non-chained archives, but may never be null.</returns>
+        /// <remarks>The archive name is the name stored within the archive, used for
+        /// identification of the archive especially among archive chains. That
+        /// name is often, but not necessarily the same as the filename of the
+        /// archive package.</remarks>
+        string GetArchiveName(int archiveNumber);
+
+        /// <summary>
+        /// Opens a stream for writing an archive package.
+        /// </summary>
+        /// <param name="archiveNumber">The 0-based index of the archive within
+        /// the chain.</param>
+        /// <param name="archiveName">The name of the archive that was returned
+        /// by <see cref="GetArchiveName"/>.</param>
+        /// <param name="truncate">True if the stream should be truncated when
+        /// opened (if it already exists); false if an existing stream is being
+        /// re-opened for writing additional data.</param>
+        /// <param name="compressionEngine">Instance of the compression engine
+        /// doing the operations.</param>
+        /// <returns>A writable Stream where the compressed archive bytes will be
+        /// written, or null to cancel the archive creation.</returns>
+        /// <remarks>
+        /// If this method returns null, the archive engine will throw a
+        /// FileNotFoundException.
+        /// </remarks>
+        Stream OpenArchiveWriteStream(
+            int archiveNumber,
+            string archiveName,
+            bool truncate,
+            CompressionEngine compressionEngine);
+
+        /// <summary>
+        /// Closes a stream where an archive package was written.
+        /// </summary>
+        /// <param name="archiveNumber">The 0-based index of the archive within
+        /// the chain.</param>
+        /// <param name="archiveName">The name of the archive that was previously
+        /// returned by
+        /// <see cref="GetArchiveName"/>.</param>
+        /// <param name="stream">A stream that was previously returned by
+        /// <see cref="OpenArchiveWriteStream"/> and is now ready to be closed.</param>
+        /// <remarks>
+        /// If there is another archive package in the chain, then after this stream
+        /// is closed a new stream will be opened.
+        /// </remarks>
+        void CloseArchiveWriteStream(int archiveNumber, string archiveName, Stream stream);
+
+        /// <summary>
+        /// Opens a stream to read a file that is to be included in an archive.
+        /// </summary>
+        /// <param name="path">The path of the file within the archive. This is often,
+        /// but not necessarily, the same as the relative path of the file outside
+        /// the archive.</param>
+        /// <param name="attributes">Returned attributes of the opened file, to be
+        /// stored in the archive.</param>
+        /// <param name="lastWriteTime">Returned last-modified time of the opened file,
+        /// to be stored in the archive.</param>
+        /// <returns>A readable Stream where the file bytes will be read from before
+        /// they are compressed, or null to skip inclusion of the file and continue to
+        /// the next file.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1021:AvoidOutParameters")]
+        Stream OpenFileReadStream(
+            string path,
+            out FileAttributes attributes,
+            out DateTime lastWriteTime);
+
+        /// <summary>
+        /// Closes a stream that has been used to read a file.
+        /// </summary>
+        /// <param name="path">The path of the file within the archive; the same as
+        /// the path provided
+        /// when the stream was opened.</param>
+        /// <param name="stream">A stream that was previously returned by
+        /// <see cref="OpenFileReadStream"/> and is now ready to be closed.</param>
+        void CloseFileReadStream(string path, Stream stream);
+
+        /// <summary>
+        /// Gets extended parameter information specific to the compression
+        /// format being used.
+        /// </summary>
+        /// <param name="optionName">Name of the option being requested.</param>
+        /// <param name="parameters">Parameters for the option; for per-file options,
+        /// the first parameter is typically the internal file path.</param>
+        /// <returns>Option value, or null to use the default behavior.</returns>
+        /// <remarks>
+        /// This method provides a way to set uncommon options during packaging, or a
+        /// way to handle aspects of compression formats not supported by the base library.
+        /// <para>For example, this may be used by the zip compression library to
+        /// specify different compression methods/levels on a per-file basis.</para>
+        /// <para>The available option names, parameters, and expected return values
+        /// should be documented by each compression library.</para>
+        /// </remarks>
+        object GetOption(string optionName, object[] parameters);
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression/IUnpackStreamContext.cs b/src/dtf/WixToolset.Dtf.Compression/IUnpackStreamContext.cs
new file mode 100644
index 00000000..f0bc6aad
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression/IUnpackStreamContext.cs
@@ -0,0 +1,71 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression
+{
+    using System;
+    using System.IO;
+
+    /// <summary>
+    /// This interface provides the methods necessary for the <see cref="CompressionEngine"/> to open
+    /// and close streams for archives and files. The implementor of this interface can use any
+    /// kind of logic to determine what kind of streams to open and where 
+    /// </summary>
+    public interface IUnpackStreamContext
+    {
+        /// <summary>
+        /// Opens the archive stream for reading.
+        /// </summary>
+        /// <param name="archiveNumber">The zero-based index of the archive to open.</param>
+        /// <param name="archiveName">The name of the archive being opened.</param>
+        /// <param name="compressionEngine">Instance of the compression engine doing the operations.</param>
+        /// <returns>A stream from which archive bytes are read, or null to cancel extraction
+        /// of the archive.</returns>
+        /// <remarks>
+        /// When the first archive in a chain is opened, the name is not yet known, so the
+        /// provided value will be an empty string. When opening further archives, the
+        /// provided value is the next-archive name stored in the previous archive. This
+        /// name is often, but not necessarily, the same as the filename of the archive
+        /// package to be opened.
+        /// <para>If this method returns null, the archive engine will throw a
+        /// FileNotFoundException.</para>
+        /// </remarks>
+        Stream OpenArchiveReadStream(int archiveNumber, string archiveName, CompressionEngine compressionEngine);
+
+        /// <summary>
+        /// Closes a stream where an archive package was read.
+        /// </summary>
+        /// <param name="archiveNumber">The archive number of the stream to close.</param>
+        /// <param name="archiveName">The name of the archive being closed.</param>
+        /// <param name="stream">The stream that was previously returned by
+        /// <see cref="OpenArchiveReadStream"/> and is now ready to be closed.</param>
+        void CloseArchiveReadStream(int archiveNumber, string archiveName, Stream stream);
+
+        /// <summary>
+        /// Opens a stream for writing extracted file bytes.
+        /// </summary>
+        /// <param name="path">The path of the file within the archive. This is often, but
+        /// not necessarily, the same as the relative path of the file outside the archive.</param>
+        /// <param name="fileSize">The uncompressed size of the file to be extracted.</param>
+        /// <param name="lastWriteTime">The last write time of the file to be extracted.</param>
+        /// <returns>A stream where extracted file bytes are to be written, or null to skip
+        /// extraction of the file and continue to the next file.</returns>
+        /// <remarks>
+        /// The implementor may use the path, size and date information to dynamically
+        /// decide whether or not the file should be extracted.
+        /// </remarks>
+        Stream OpenFileWriteStream(string path, long fileSize, DateTime lastWriteTime);
+
+        /// <summary>
+        /// Closes a stream where an extracted file was written.
+        /// </summary>
+        /// <param name="path">The path of the file within the archive.</param>
+        /// <param name="stream">The stream that was previously returned by <see cref="OpenFileWriteStream"/>
+        /// and is now ready to be closed.</param>
+        /// <param name="attributes">The attributes of the extracted file.</param>
+        /// <param name="lastWriteTime">The last write time of the file.</param>
+        /// <remarks>
+        /// The implementor may wish to apply the attributes and date to the newly-extracted file.
+        /// </remarks>
+        void CloseFileWriteStream(string path, Stream stream, FileAttributes attributes, DateTime lastWriteTime);
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression/OffsetStream.cs b/src/dtf/WixToolset.Dtf.Compression/OffsetStream.cs
new file mode 100644
index 00000000..65562524
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression/OffsetStream.cs
@@ -0,0 +1,206 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression
+{
+    using System;
+    using System.IO;
+
+    /// <summary>
+    /// Wraps a source stream and offsets all read/write/seek calls by a given value.
+    /// </summary>
+    /// <remarks>
+    /// This class is used to trick archive an packing or unpacking process
+    /// into reading or writing at an offset into a file, primarily for
+    /// self-extracting packages.
+    /// </remarks>
+    public class OffsetStream : Stream
+    {
+        private Stream source;
+        private long sourceOffset;
+
+        /// <summary>
+        /// Creates a new OffsetStream instance from a source stream
+        /// and using a specified offset.
+        /// </summary>
+        /// <param name="source">Underlying stream for which all calls will be offset.</param>
+        /// <param name="offset">Positive or negative number of bytes to offset.</param>
+        public OffsetStream(Stream source, long offset)
+        {
+            if (source == null)
+            {
+                throw new ArgumentNullException("source");
+            }
+
+            this.source = source;
+            this.sourceOffset = offset;
+
+            this.source.Seek(this.sourceOffset, SeekOrigin.Current);
+        }
+
+        /// <summary>
+        /// Gets the underlying stream that this OffsetStream calls into.
+        /// </summary>
+        public Stream Source
+        {
+            get { return this.source; }
+        }
+
+        /// <summary>
+        /// Gets the number of bytes to offset all calls before
+        /// redirecting to the underlying stream.
+        /// </summary>
+        public long Offset
+        {
+            get { return this.sourceOffset; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the source stream supports reading.
+        /// </summary>
+        /// <value>true if the stream supports reading; otherwise, false.</value>
+        public override bool CanRead
+        {
+            get
+            {
+                return this.source.CanRead;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the source stream supports writing.
+        /// </summary>
+        /// <value>true if the stream supports writing; otherwise, false.</value>
+        public override bool CanWrite
+        {
+            get
+            {
+                return this.source.CanWrite;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the source stream supports seeking.
+        /// </summary>
+        /// <value>true if the stream supports seeking; otherwise, false.</value>
+        public override bool CanSeek
+        {
+            get
+            {
+                return this.source.CanSeek;
+            }
+        }
+
+        /// <summary>
+        /// Gets the effective length of the stream, which is equal to
+        /// the length of the source stream minus the offset.
+        /// </summary>
+        public override long Length
+        {
+            get { return this.source.Length - this.sourceOffset; } 
+        }
+
+        /// <summary>
+        /// Gets or sets the effective position of the stream, which
+        /// is equal to the position of the source stream minus the offset.
+        /// </summary>
+        public override long Position
+        {
+            get { return this.source.Position - this.sourceOffset; }
+            set { this.source.Position = value + this.sourceOffset; }
+        }
+
+        /// <summary>
+        /// Reads a sequence of bytes from the source stream and advances
+        /// the position within the stream by the number of bytes read.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. When this method returns, the buffer
+        /// contains the specified byte array with the values between offset and
+        /// (offset + count - 1) replaced by the bytes read from the current source.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which to begin
+        /// storing the data read from the current stream.</param>
+        /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
+        /// <returns>The total number of bytes read into the buffer. This can be less
+        /// than the number of bytes requested if that many bytes are not currently available,
+        /// or zero (0) if the end of the stream has been reached.</returns>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            return this.source.Read(buffer, offset, count);
+        }
+
+        /// <summary>
+        /// Writes a sequence of bytes to the source stream and advances the
+        /// current position within this stream by the number of bytes written.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. This method copies count
+        /// bytes from buffer to the current stream.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which
+        /// to begin copying bytes to the current stream.</param>
+        /// <param name="count">The number of bytes to be written to the
+        /// current stream.</param>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            this.source.Write(buffer, offset, count);
+        }
+
+        /// <summary>
+        /// Reads a byte from the stream and advances the position within the
+        /// source stream by one byte, or returns -1 if at the end of the stream.
+        /// </summary>
+        /// <returns>The unsigned byte cast to an Int32, or -1 if at the
+        /// end of the stream.</returns>
+        public override int ReadByte()
+        {
+            return this.source.ReadByte();
+        }
+
+        /// <summary>
+        /// Writes a byte to the current position in the source stream and
+        /// advances the position within the stream by one byte.
+        /// </summary>
+        /// <param name="value">The byte to write to the stream.</param>
+        public override void WriteByte(byte value)
+        {
+            this.source.WriteByte(value);
+        }
+
+        /// <summary>
+        /// Flushes the source stream.
+        /// </summary>
+        public override void Flush()
+        {
+            this.source.Flush();
+        }
+
+        /// <summary>
+        /// Sets the position within the current stream, which is
+        /// equal to the position within the source stream minus the offset.
+        /// </summary>
+        /// <param name="offset">A byte offset relative to the origin parameter.</param>
+        /// <param name="origin">A value of type SeekOrigin indicating
+        /// the reference point used to obtain the new position.</param>
+        /// <returns>The new position within the current stream.</returns>
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            return this.source.Seek(offset + (origin == SeekOrigin.Begin ? this.sourceOffset : 0), origin) - this.sourceOffset;
+        }
+
+        /// <summary>
+        /// Sets the effective length of the stream, which is equal to
+        /// the length of the source stream minus the offset.
+        /// </summary>
+        /// <param name="value">The desired length of the
+        /// current stream in bytes.</param>
+        public override void SetLength(long value)
+        {
+            this.source.SetLength(value + this.sourceOffset);
+        }
+
+        /// <summary>
+        /// Closes the underlying stream.
+        /// </summary>
+        public override void Close()
+        {
+            this.source.Close();
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression/SafeNativeMethods.cs b/src/dtf/WixToolset.Dtf.Compression/SafeNativeMethods.cs
new file mode 100644
index 00000000..1829ba81
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression/SafeNativeMethods.cs
@@ -0,0 +1,22 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression
+{
+    using System;
+    using System.Security;
+    using System.Runtime.InteropServices;
+
+    [SuppressUnmanagedCodeSecurity]
+    internal static class SafeNativeMethods
+    {
+        [DllImport("kernel32.dll", SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool DosDateTimeToFileTime(
+            short wFatDate, short wFatTime, out long fileTime);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool FileTimeToDosDateTime(
+            ref long fileTime, out short wFatDate, out short wFatTime);
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression/WixToolset.Dtf.Compression.csproj b/src/dtf/WixToolset.Dtf.Compression/WixToolset.Dtf.Compression.csproj
new file mode 100644
index 00000000..e49a446b
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression/WixToolset.Dtf.Compression.csproj
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. -->
+
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <RootNamespace>WixToolset.Dtf.Compression</RootNamespace>
+    <AssemblyName>WixToolset.Dtf.Compression</AssemblyName>
+    <TargetFrameworks>netstandard2.0;net20</TargetFrameworks>
+    <Description>Abstract base libraries for archive packing and unpacking</Description>
+    <CreateDocumentationFile>true</CreateDocumentationFile>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="Compression.cd" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
+    <PackageReference Include="Nerdbank.GitVersioning" Version="3.3.37" PrivateAssets="All" />
+  </ItemGroup>
+</Project>